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 Predicate from "effect/Predicate";
import {
DEFAULT_MODEL,
type ProviderInteractionMode,
type ProviderUserInputAnswers,
RuntimeMode,
} from "@akeru/contracts";
import { normalizeModelSlug } from "@akeru/shared/model";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as CodexErrors from "effect-codex-app-server/errors";
import * as EffectCodexSchema from "effect-codex-app-server/schema";
import { buildCodexDeveloperInstructions } from "../../CodexDeveloperInstructions.ts";
import { type CodexServiceTier } from "./CodexRuntimeState.ts";
import { CodexSessionRuntimeInvalidUserInputAnswersError } from "./CodexRuntimeErrors.ts";
export const decodeV2TurnStartResponse = Schema.decodeUnknownEffect(
EffectCodexSchema.V2TurnStartResponse,
);
export function hasConfiguredMcpServer(appServerArgs: ReadonlyArray<string> | undefined): boolean {
return appServerArgs?.some((argument) => argument.includes("mcp_servers.")) === true;
}
export const CodexResumeCursorSchema = Schema.Struct({
threadId: Schema.String,
});
export const CodexUserInputAnswerObject = Schema.Struct({
answers: Schema.Array(Schema.String),
});
export const isCodexResumeCursorSchema = Schema.is(CodexResumeCursorSchema);
export const isCodexUserInputAnswerObject = Schema.is(CodexUserInputAnswerObject);
// TODO: Verify `packages/effect-codex-app-server/scripts/generate.ts` so the generated
// `V2TurnStartParams` schema includes `collaborationMode` directly.
export const CodexTurnStartParamsWithCollaborationMode = EffectCodexSchema.V2TurnStartParams.pipe(
Schema.fieldsAssign({
collaborationMode: Schema.optionalKey(EffectCodexSchema.V2TurnStartParams__CollaborationMode),
}),
);
export const decodeCodexTurnStartParamsWithCollaborationMode = Schema.decodeUnknownEffect(
CodexTurnStartParamsWithCollaborationMode,
);
export type CodexTurnStartParamsWithCollaborationMode =
typeof CodexTurnStartParamsWithCollaborationMode.Type;
export type CodexResumeCursor = typeof CodexResumeCursorSchema.Type;
export function normalizeCodexModelSlug(
model: string | undefined | null,
preferredId?: string,
): string | undefined {
const normalized = normalizeModelSlug(model);
if (!normalized) {
return undefined;
}
if (preferredId?.endsWith("-codex") && preferredId !== normalized) {
return preferredId;
}
return normalized;
}
type CodexThreadRuntimePolicy = {
[Key in "approvalPolicy" | "sandbox" | "approvalsReviewer"]-?: NonNullable<
EffectCodexSchema.V2ThreadStartParams[Key]
>;
};
export function runtimeModeToThreadConfig(input: RuntimeMode): CodexThreadRuntimePolicy {
switch (input) {
case "approval-required":
return {
approvalPolicy: "untrusted",
sandbox: "read-only",
approvalsReviewer: "user",
};
case "auto-accept-edits":
return {
approvalPolicy: "on-request",
sandbox: "workspace-write",
approvalsReviewer: "user",
};
case "auto":
return {
approvalPolicy: "on-request",
sandbox: "workspace-write",
approvalsReviewer: "auto_review",
};
case "full-access":
default:
return {
approvalPolicy: "never",
sandbox: "danger-full-access",
approvalsReviewer: "user",
};
}
}
export function buildThreadStartParams(input: {
readonly cwd: string;
readonly runtimeMode: RuntimeMode;
readonly model: string | undefined;
readonly serviceTier: CodexServiceTier | undefined;
}): EffectCodexSchema.V2ThreadStartParams {
const config = runtimeModeToThreadConfig(input.runtimeMode);
return {
cwd: input.cwd,
approvalPolicy: config.approvalPolicy,
sandbox: config.sandbox,
approvalsReviewer: config.approvalsReviewer,
...(input.model ? { model: input.model } : {}),
...(input.serviceTier ? { serviceTier: input.serviceTier } : {}),
};
}
export function runtimeModeToTurnSandboxPolicy(
input: RuntimeMode,
): EffectCodexSchema.V2TurnStartParams__SandboxPolicy {
switch (input) {
case "approval-required":
return {
type: "readOnly",
};
case "auto-accept-edits":
case "auto":
return {
type: "workspaceWrite",
};
case "full-access":
default:
return {
type: "dangerFullAccess",
};
}
}
export function buildCodexCollaborationMode(input: {
readonly interactionMode?: ProviderInteractionMode;
readonly model?: string;
readonly effort?: EffectCodexSchema.V2TurnStartParams__ReasoningEffort;
readonly browserToolsAvailable?: boolean;
}): EffectCodexSchema.V2TurnStartParams__CollaborationMode | undefined {
if (input.interactionMode === undefined) {
return undefined;
}
const model = normalizeCodexModelSlug(input.model) ?? DEFAULT_MODEL;
const reasoningEffort = input.effort ?? "medium";
// Plan mode is retired; every turn runs in Codex's default collaboration mode.
return {
mode: "default",
settings: {
model,
reasoning_effort: reasoningEffort,
developer_instructions: buildCodexDeveloperInstructions(
{ model, reasoningEffort },
input.browserToolsAvailable ?? true,
),
},
};
}
export function buildTurnStartParams(input: {
readonly threadId: string;
readonly runtimeMode: RuntimeMode;
readonly prompt?: string;
readonly attachments?: ReadonlyArray<{
readonly type: "image";
readonly url: string;
}>;
readonly model?: string;
readonly serviceTier?: CodexServiceTier;
readonly effort?: EffectCodexSchema.V2TurnStartParams__ReasoningEffort;
readonly interactionMode?: ProviderInteractionMode;
/** Defaults to true so callers that predate the agent-access gate are unchanged. */
readonly browserToolsAvailable?: boolean;
}): Effect.Effect<
CodexTurnStartParamsWithCollaborationMode,
CodexErrors.CodexAppServerProtocolParseError
> {
const turnInput: Array<EffectCodexSchema.V2TurnStartParams__UserInput> = [];
if (input.prompt) {
turnInput.push({
type: "text",
text: input.prompt,
});
}
for (const attachment of input.attachments ?? []) {
turnInput.push(attachment);
}
const config = runtimeModeToThreadConfig(input.runtimeMode);
const collaborationMode = buildCodexCollaborationMode({
...(input.interactionMode ? { interactionMode: input.interactionMode } : {}),
...(input.model ? { model: input.model } : {}),
...(input.effort ? { effort: input.effort } : {}),
browserToolsAvailable: input.browserToolsAvailable ?? true,
});
return decodeCodexTurnStartParamsWithCollaborationMode({
threadId: input.threadId,
input: turnInput,
approvalPolicy: config.approvalPolicy,
approvalsReviewer: config.approvalsReviewer,
sandboxPolicy: runtimeModeToTurnSandboxPolicy(input.runtimeMode),
...(input.model ? { model: input.model } : {}),
...(input.serviceTier ? { serviceTier: input.serviceTier } : {}),
...(input.effort ? { effort: input.effort } : {}),
...(collaborationMode ? { collaborationMode } : {}),
}).pipe(
Effect.mapError((cause) =>
CodexErrors.CodexAppServerProtocolParseError.fromSchemaError(
"decode-request-payload",
cause,
{ method: "turn/start" },
),
),
);
}
export function toCodexUserInputAnswer(
questionId: string,
value: ProviderUserInputAnswers[string],
): Effect.Effect<
EffectCodexSchema.ToolRequestUserInputResponse__ToolRequestUserInputAnswer,
CodexSessionRuntimeInvalidUserInputAnswersError
> {
if (Predicate.isString(value)) {
return Effect.succeed({ answers: [value] });
}
if (Array.isArray(value)) {
const answers = value.filter((entry): entry is string => Predicate.isString(entry));
return Effect.succeed({ answers });
}
if (isCodexUserInputAnswerObject(value)) {
return Effect.succeed({ answers: value.answers });
}
return Effect.fail(new CodexSessionRuntimeInvalidUserInputAnswersError({ questionId }));
}
export function toCodexUserInputAnswers(
answers: ProviderUserInputAnswers,
): Effect.Effect<
EffectCodexSchema.ToolRequestUserInputResponse["answers"],
CodexSessionRuntimeInvalidUserInputAnswersError
> {
return Effect.forEach(
Object.entries(answers),
([questionId, value]) =>
toCodexUserInputAnswer(questionId, value).pipe(
Effect.map((answer) => [questionId, answer] as const),
),
{ concurrency: 1 },
).pipe(Effect.map((entries) => Object.fromEntries(entries)));
}