Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
import * as Schema from "effect/Schema";
import * as SchemaIssue from "effect/SchemaIssue";
import * as Struct from "effect/Struct";
import {
CheckpointRef,
IsoDateTime,
MessageId,
NonNegativeInt,
ProjectId,
ThreadId,
TrimmedNonEmptyString,
TrimmedString,
TurnId,
} from "../baseSchemas.ts";
import { ProviderApprovalDecision } from "./modelSelection.ts";
import { ChannelFailureCategory } from "./roster.ts";
import { OrchestrationCheckpointFile, OrchestrationCheckpointStatus } from "./thread.ts";
import {
OrchestrationShellSnapshot,
OrchestrationShellStreamItem,
OrchestrationSubscribeShellInput,
OrchestrationSubscribeThreadInput,
} from "./readModel.ts";
import { ClientOrchestrationCommand } from "./commands.ts";
import { OrchestrationThreadStreamItem } from "./threadStream.ts";
export const OrchestrationCommandReceiptStatus = Schema.Literals(["accepted", "rejected"]);
export type OrchestrationCommandReceiptStatus = typeof OrchestrationCommandReceiptStatus.Type;
export const TurnCountRange = Schema.Struct({
fromTurnCount: NonNegativeInt,
toTurnCount: NonNegativeInt,
}).check(
Schema.makeFilter(
(input) =>
input.fromTurnCount <= input.toTurnCount ||
new SchemaIssue.InvalidValue({
message: "fromTurnCount must be less than or equal to toTurnCount",
}),
{ identifier: "OrchestrationTurnDiffRange" },
),
);
export const ThreadTurnDiff = TurnCountRange.mapFields(
Struct.assign({
threadId: ThreadId,
diff: Schema.String,
}),
{ unsafePreserveChecks: true },
);
export const ProviderSessionRuntimeStatus = Schema.Literals([
"starting",
"running",
"stopped",
"error",
]);
export type ProviderSessionRuntimeStatus = typeof ProviderSessionRuntimeStatus.Type;
const ProjectionThreadTurnStatus = Schema.Literals([
"running",
"completed",
"interrupted",
"error",
]);
export type ProjectionThreadTurnStatus = typeof ProjectionThreadTurnStatus.Type;
const ProjectionCheckpointRow = Schema.Struct({
threadId: ThreadId,
turnId: TurnId,
checkpointTurnCount: NonNegativeInt,
checkpointRef: CheckpointRef,
status: OrchestrationCheckpointStatus,
files: Schema.Array(OrchestrationCheckpointFile),
assistantMessageId: Schema.NullOr(MessageId),
completedAt: IsoDateTime,
});
export type ProjectionCheckpointRow = typeof ProjectionCheckpointRow.Type;
export const ProjectionPendingApprovalStatus = Schema.Literals(["pending", "resolved"]);
export type ProjectionPendingApprovalStatus = typeof ProjectionPendingApprovalStatus.Type;
export const ProjectionPendingApprovalDecision = Schema.NullOr(ProviderApprovalDecision);
export type ProjectionPendingApprovalDecision = typeof ProjectionPendingApprovalDecision.Type;
export const DispatchResult = Schema.Struct({
sequence: NonNegativeInt,
});
export type DispatchResult = typeof DispatchResult.Type;
export const OrchestrationGetTurnDiffInput = TurnCountRange.mapFields(
Struct.assign({
threadId: ThreadId,
ignoreWhitespace: Schema.optionalKey(Schema.Boolean),
}),
{ unsafePreserveChecks: true },
);
export type OrchestrationGetTurnDiffInput = typeof OrchestrationGetTurnDiffInput.Type;
export const OrchestrationGetTurnDiffResult = ThreadTurnDiff;
export type OrchestrationGetTurnDiffResult = typeof OrchestrationGetTurnDiffResult.Type;
export const OrchestrationGetFullThreadDiffInput = Schema.Struct({
threadId: ThreadId,
toTurnCount: NonNegativeInt,
ignoreWhitespace: Schema.optionalKey(Schema.Boolean),
});
export type OrchestrationGetFullThreadDiffInput = typeof OrchestrationGetFullThreadDiffInput.Type;
export const OrchestrationGetFullThreadDiffResult = ThreadTurnDiff;
export type OrchestrationGetFullThreadDiffResult = typeof OrchestrationGetFullThreadDiffResult.Type;
export const OrchestrationThreadSearchSource = Schema.Literals(["user", "assistant"]);
export type OrchestrationThreadSearchSource = typeof OrchestrationThreadSearchSource.Type;
// The server's SQLite client is synchronous and single-connection. Bound both
// scan input and response size so a search cannot monopolize that connection.
export const OrchestrationSearchThreadsInput = Schema.Struct({
query: TrimmedString.check(Schema.isMinLength(2), Schema.isMaxLength(200)),
limit: Schema.optionalKey(Schema.Int.check(Schema.isBetween({ minimum: 1, maximum: 50 }))),
});
export type OrchestrationSearchThreadsInput = typeof OrchestrationSearchThreadsInput.Type;
export const OrchestrationThreadSearchMatch = Schema.Struct({
threadId: ThreadId,
projectId: ProjectId,
source: OrchestrationThreadSearchSource,
snippet: Schema.String.check(Schema.isMaxLength(240)),
messageCreatedAt: Schema.NullOr(IsoDateTime),
});
export type OrchestrationThreadSearchMatch = typeof OrchestrationThreadSearchMatch.Type;
export const OrchestrationSearchThreadsResult = Schema.Struct({
matches: Schema.Array(OrchestrationThreadSearchMatch),
});
export type OrchestrationSearchThreadsResult = typeof OrchestrationSearchThreadsResult.Type;
export const OrchestrationGetWorkflowScriptInput = Schema.Struct({
threadId: ThreadId,
/** Absolute path from the workflow's runHandles.scriptPath. The server
* re-derives containment; the client value is a hint, never trusted. */
scriptPath: TrimmedNonEmptyString,
});
export type OrchestrationGetWorkflowScriptInput = typeof OrchestrationGetWorkflowScriptInput.Type;
export const OrchestrationGetWorkflowScriptResult = Schema.Struct({
scriptPath: TrimmedNonEmptyString,
contents: Schema.String,
truncated: Schema.Boolean,
});
export type OrchestrationGetWorkflowScriptResult = typeof OrchestrationGetWorkflowScriptResult.Type;
const WORKFLOW_SCRIPT_ERROR_MESSAGES = {
"invalid-path": "Workflow scripts must be absolute .js paths.",
"root-unavailable": "Script root unavailable.",
"not-found": "Script not found.",
"outside-root": "Script path is outside the workflow scripts root.",
"not-js": "Resolved script is not a .js file.",
"not-regular-file": "Script is not a regular file.",
"changed-during-read": "Script changed between resolution and open.",
"read-failed": "Script read failed.",
} as const;
export class OrchestrationGetWorkflowScriptError extends Schema.TaggedErrorClass<OrchestrationGetWorkflowScriptError>()(
"OrchestrationGetWorkflowScriptError",
{
reason: Schema.Literals([
"invalid-path",
"root-unavailable",
"not-found",
"outside-root",
"not-js",
"not-regular-file",
"changed-during-read",
"read-failed",
]),
scriptPath: Schema.String,
cause: Schema.optional(Schema.Defect()),
},
) {
override get message(): string {
return WORKFLOW_SCRIPT_ERROR_MESSAGES[this.reason];
}
}
export const OrchestrationRpcSchemas = {
dispatchCommand: {
input: ClientOrchestrationCommand,
output: DispatchResult,
},
getWorkflowScript: {
input: OrchestrationGetWorkflowScriptInput,
output: OrchestrationGetWorkflowScriptResult,
},
getTurnDiff: {
input: OrchestrationGetTurnDiffInput,
output: OrchestrationGetTurnDiffResult,
},
getFullThreadDiff: {
input: OrchestrationGetFullThreadDiffInput,
output: OrchestrationGetFullThreadDiffResult,
},
searchThreads: {
input: OrchestrationSearchThreadsInput,
output: OrchestrationSearchThreadsResult,
},
getArchivedShellSnapshot: {
input: Schema.Struct({}),
output: OrchestrationShellSnapshot,
},
subscribeThread: {
input: OrchestrationSubscribeThreadInput,
output: OrchestrationThreadStreamItem,
},
subscribeShell: {
input: OrchestrationSubscribeShellInput,
output: OrchestrationShellStreamItem,
},
} as const;
export class OrchestrationGetSnapshotError extends Schema.TaggedErrorClass<OrchestrationGetSnapshotError>()(
"OrchestrationGetSnapshotError",
{
message: TrimmedNonEmptyString,
cause: Schema.optional(Schema.Defect()),
},
) {}
export class OrchestrationDispatchCommandError extends Schema.TaggedErrorClass<OrchestrationDispatchCommandError>()(
"OrchestrationDispatchCommandError",
{
message: TrimmedNonEmptyString,
cause: Schema.optional(Schema.Defect()),
bootstrapThreadDisposition: Schema.optional(Schema.Literal("deleted")),
unavailability: Schema.optional(
Schema.Literals([
"missing-login",
"expired-login",
"unsupported-model",
"limit-reached",
"usage-cap",
"temporary-failure",
]),
),
repairAction: Schema.optional(TrimmedNonEmptyString),
/** Why a channel command failed, when the failure has a channel repair. */
channelFailureCategory: Schema.optional(ChannelFailureCategory),
},
) {}
export class OrchestrationGetTurnDiffError extends Schema.TaggedErrorClass<OrchestrationGetTurnDiffError>()(
"OrchestrationGetTurnDiffError",
{
message: TrimmedNonEmptyString,
cause: Schema.optional(Schema.Defect()),
},
) {}
export class OrchestrationGetFullThreadDiffError extends Schema.TaggedErrorClass<OrchestrationGetFullThreadDiffError>()(
"OrchestrationGetFullThreadDiffError",
{
message: TrimmedNonEmptyString,
cause: Schema.optional(Schema.Defect()),
},
) {}
export class OrchestrationSearchThreadsError extends Schema.TaggedErrorClass<OrchestrationSearchThreadsError>()(
"OrchestrationSearchThreadsError",
{
message: TrimmedNonEmptyString,
cause: Schema.optional(Schema.Defect()),
},
) {}