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 Effect from "effect/Effect";
import * as Predicate from "effect/Predicate";
import * as Schema from "effect/Schema";
import * as SchemaTransformation from "effect/SchemaTransformation";
import { ProviderOptionSelections } from "../model.ts";
import { TrimmedNonEmptyString } from "../baseSchemas.ts";
import { ProviderInstanceId } from "../providerInstance.ts";
export const ProviderApprovalPolicy = Schema.Literals([
"untrusted",
"on-failure",
"on-request",
"never",
]);
export type ProviderApprovalPolicy = typeof ProviderApprovalPolicy.Type;
export const ProviderSandboxMode = Schema.Literals([
"read-only",
"workspace-write",
"danger-full-access",
]);
export type ProviderSandboxMode = typeof ProviderSandboxMode.Type;
/**
* `ModelSelection` — selection of a model on a configured provider instance.
*
* The routing key is `instanceId` (a user-defined slug identifying one
* configured provider instance). Drivers, credentials, working-directory
* bindings, and any other per-instance state are recovered from the
* runtime registry via the instance id.
*
* Wire legacy: persisted selections produced before the driver/instance
* split carried a `provider: <driver-id>` field instead. The schema absorbs
* that shape via a pre-decoding transform — `{provider, model}` is promoted
* to `{instanceId: defaultInstanceIdForDriver(provider), model}`. No
* post-decode compatibility code lives in the runtime; the transform is the
* only compat surface.
*/
const ModelSelectionWire = Schema.Struct({
instanceId: ProviderInstanceId,
model: TrimmedNonEmptyString,
options: Schema.optionalKey(ProviderOptionSelections),
});
// Source shape for persisted legacy payloads. Fields are typed as
// `Schema.Unknown` so malformed drafts still make it into the transform and
// fail validation through the target schema (with proper error messages)
// rather than at the source-struct layer where the error is less actionable.
const ModelSelectionSource = Schema.Struct({
provider: Schema.optional(Schema.Unknown),
instanceId: Schema.optional(Schema.Unknown),
model: Schema.Unknown,
options: Schema.optional(Schema.Unknown),
});
export const ModelSelection = ModelSelectionSource.pipe(
Schema.decodeTo(
ModelSelectionWire,
SchemaTransformation.transformOrFail({
decode: (raw) => {
// Resolve the routing key: prefer an explicit `instanceId`; fall
// back to promoting the legacy `provider` slug (the canonical
// `defaultInstanceIdForDriver` mapping) so persisted rollout-era
// payloads decode without data loss. The target schema brands the
// string as `ProviderInstanceId`.
const instanceIdSource =
raw.instanceId !== undefined
? raw.instanceId
: Predicate.isString(raw.provider)
? raw.provider
: undefined;
const base = {
instanceId: instanceIdSource,
model: raw.model,
...(raw.options !== undefined ? { options: raw.options } : {}),
};
// SAFETY: decodeTo validates the compatibility result against ModelSelectionWire before returning it.
return Effect.succeed(base as typeof ModelSelectionWire.Encoded);
},
encode: (value) => {
return Effect.succeed({
model: value.model,
instanceId: value.instanceId,
...(value.options !== undefined ? { options: value.options } : {}),
});
},
}),
),
);
export type ModelSelection = typeof ModelSelection.Type;
export const RuntimeMode = Schema.Literals([
"approval-required",
"auto-accept-edits",
"auto",
"full-access",
]);
export type RuntimeMode = typeof RuntimeMode.Type;
// Event decoders keep the historical full-access fallback for old persisted data.
export const DEFAULT_RUNTIME_MODE: RuntimeMode = "full-access";
export const LocalExecutionMode = Schema.Literals(["approval-required", "auto", "full-access"]);
export type LocalExecutionMode = typeof LocalExecutionMode.Type;
export const DEFAULT_LOCAL_EXECUTION_MODE: LocalExecutionMode = "auto";
export const ProviderInteractionMode = Schema.Literals(["default", "plan"]);
export type ProviderInteractionMode = typeof ProviderInteractionMode.Type;
export const DEFAULT_PROVIDER_INTERACTION_MODE: ProviderInteractionMode = "default";
export const ProviderRequestKind = Schema.Literals([
"command",
"file-read",
"file-change",
"mcp-elicitation",
]);
export type ProviderRequestKind = typeof ProviderRequestKind.Type;
export const AssistantDeliveryMode = Schema.Literals(["buffered", "streaming"]);
export type AssistantDeliveryMode = typeof AssistantDeliveryMode.Type;
export const ProviderApprovalDecision = Schema.Literals([
"accept",
"acceptForSession",
"acceptAlways",
"decline",
"cancel",
]);
export type ProviderApprovalDecision = typeof ProviderApprovalDecision.Type;
export const ProviderApprovalOption = Schema.Struct({
decision: ProviderApprovalDecision,
label: TrimmedNonEmptyString,
});
export type ProviderApprovalOption = typeof ProviderApprovalOption.Type;
export const ProviderUserInputAnswers = Schema.Record(Schema.String, Schema.Unknown);
export type ProviderUserInputAnswers = typeof ProviderUserInputAnswers.Type;