@xfey/tutti 0.1.0

package/dist/control-plane/types.d.ts

@@ -0,0 +1,155 @@
+import type { AccountAvatarProjection, RunLineage } from "@tutti/shared/domain";
+import type { RuntimeLogger } from "@tutti/shared/utils";
+import type { ActivityRef, ClarificationRoundRef, TaskId, TaskModuleId } from "@tutti/shared/ids";
+import type { ActiveApprovalProjection, ClarificationRequestPayload, MessageProjection, RecoverySummaryProjection, TaskDetailProjection, TaskProjection } from "@tutti/shared/schemas/api";
+import type { HostProjectStore } from "../store/index.js";
+import type { WorkspaceEventBus } from "../server-shell/http/workspace-events.js";
+import type { CleanupStaleRunWorkspacesResult } from "../workspace-ops/index.js";
+import type { ProcedureWorkflowRunnerResolver } from "./workflows/index.js";
+export type Phase5ControlPlaneOptions = {
+    store: HostProjectStore;
+    events: WorkspaceEventBus;
+    resolveWorkflowRunner: ProcedureWorkflowRunnerResolver;
+    resolveRunPipeline?: RunPipelineResolver;
+    readMainlineStatus?: () => {
+        mainline_clean: boolean;
+    };
+    readActiveApproval?: () => ActiveApprovalProjection;
+    logger?: ControlPlaneLogger;
+    projectContext?: {
+        workspaceRoot: string;
+        projectName: string;
+    };
+    now?: () => Date;
+};
+export type ControlPlaneLogger = Pick<RuntimeLogger, "info">;
+export type TrustedHumanAuthor = {
+    account_ref: string;
+    display_name: string;
+    avatar?: AccountAvatarProjection;
+};
+export type ControlPlaneCommandResult<TDisposition, TResult> = {
+    disposition: TDisposition;
+    result?: TResult;
+};
+export type StartupRecoveryOptions = {
+    cleanupStaleRunWorkspaces?: () => CleanupStaleRunWorkspacesResult;
+    interruptedCommandCount?: number;
+};
+export type StartupRecoveryResult = {
+    kind: "noop";
+} | {
+    kind: "recovered";
+    recovery_summary: RecoverySummaryProjection;
+    recovered_run_count: number;
+    replayed_round_ids: ClarificationRoundRef[];
+    interrupted_command_count: number;
+    removed_run_workspace_count: number;
+    removed_temp_branch_count: number;
+    cleanup_warning_count: number;
+    stale_replay_hint_count: number;
+};
+export type RunDispatchTrigger = "auto_idle" | "task_arrival" | "manual_run_now" | "continuation" | "recovery";
+export type RunDispatchContext = {
+    trigger: RunDispatchTrigger;
+    queue_scope: {
+        kind: "worklist";
+    };
+    current_task_id: TaskId;
+    ordered_task_refs: TaskId[];
+    current_module_id?: TaskModuleId;
+};
+export type RunContinuationContext = {
+    previous_run: {
+        summary: string;
+        clarification_request_payload: ClarificationRequestPayload;
+    };
+    clarification: {
+        resolved_rounds: Array<{
+            request_payload: ClarificationRequestPayload;
+            answer_messages: Array<{
+                author: MessageProjection["author"];
+                text: string;
+                created_at: string;
+            }>;
+        }>;
+        messages_truncated: boolean;
+    };
+    follow_up_check: {
+        decision: "resume";
+        summary: string;
+    };
+};
+export type RunCorrectionContext = {
+    summary: string;
+    reason_code: string;
+    guidance: string;
+    promotion_failure?: {
+        reason_code: string;
+        summary: string;
+    };
+};
+export type RunPipelineInput = {
+    activity_ref: ActivityRef;
+    task: TaskProjection;
+    task_detail: TaskDetailProjection;
+    run_lineage: RunLineage;
+    dispatch_context: RunDispatchContext;
+    continuation_context?: RunContinuationContext;
+    correction_context?: RunCorrectionContext;
+    on_stage?: (progress: RunPipelineStageProgress) => void;
+};
+export type RunPipelineStageProgress = {
+    stage: string;
+    summary: string;
+};
+export type RunPipelineTimelineEvent = {
+    event_kind: "promotion_reconcile";
+    status: "completed" | "failed";
+    summary: string;
+    commit_oid?: string;
+    meta?: string[];
+};
+type RunPipelineResultMetadata = {
+    timeline_events?: RunPipelineTimelineEvent[];
+};
+export type RunPipelineResult = RunPipelineResultMetadata & ({
+    result_kind: "needs_human";
+    summary: string;
+    clarification_request_payload: ClarificationRequestPayload;
+    changed_paths?: string[];
+} | {
+    result_kind: "finished";
+    outcome: "completed" | "failed";
+    summary: string;
+    checks: "passed" | "failed" | "skipped";
+    docs: "updated" | "checked_no_change" | "not_checked" | "sync_deferred";
+    skip_reason_code?: NonNullable<TaskDetailProjection["detail"]["result"]["skip_reason_code"]>;
+    skip_reason_summary?: string;
+    external_side_effects?: TaskDetailProjection["detail"]["result"]["external_side_effects"];
+    changed_paths?: string[];
+    promotion?: NonNullable<TaskDetailProjection["detail"]["result"]["promotion"]>;
+} | {
+    result_kind: "failed";
+    summary: string;
+    error_code: string;
+    retryable: boolean;
+    changed_paths?: string[];
+    promotion?: NonNullable<TaskDetailProjection["detail"]["result"]["promotion"]>;
+});
+export type RunPipelineRunner = {
+    runTask: (input: RunPipelineInput) => Promise<RunPipelineResult>;
+};
+export type RunPipelineResolution = {
+    kind: "ready";
+    runner: RunPipelineRunner;
+} | {
+    kind: "not_configured";
+} | {
+    kind: "unavailable";
+    reason: "provider_auth_invalid" | "provider_quota_or_billing_required" | "provider_rate_limited" | "provider_model_unavailable" | "provider_network_error";
+    retryable: boolean;
+};
+export type RunPipelineResolver = () => RunPipelineResolution;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/control-plane/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/control-plane/workflows/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./openai.js";
+export * from "./structured-output.js";
+export * from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/control-plane/workflows/index.js

@@ -0,0 +1,4 @@
+export * from "./openai.js";
+export * from "./structured-output.js";
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/dist/control-plane/workflows/openai.d.ts

@@ -0,0 +1,34 @@
+import type { ProjectId } from "@tutti/shared/ids";
+import type { ProviderUsageRecorder } from "../../provider-usage/index.js";
+import { type OpenAiStructuredOutputClient } from "../../providers/openai/sdk-procedure-runner.js";
+import { type OpenAiProviderConfig } from "../../providers/openai/provider-config.js";
+import type { ProcedureWorkflowRunner, ProcedureWorkflowRunnerResolution } from "./types.js";
+import type { CodexAppServerAgentContextRuntime } from "../../providers/openai/app-server/skills.js";
+export type OpenAiProcedureWorkflowRunnerOptions = {
+    config: OpenAiProviderConfig;
+    client: OpenAiStructuredOutputClient;
+    recordUsage?: ProviderUsageRecorder;
+    promptsRoot?: string;
+    readOnlyAppServer?: {
+        apiKey: string;
+        workspaceRoot: string;
+        codexCommand?: string;
+        requestTimeoutMs?: number;
+        turnTimeoutMs?: number;
+        baseEnv?: NodeJS.ProcessEnv;
+        tuttiHome?: string;
+        builtInSkillsRoot?: string;
+        agentContext?: CodexAppServerAgentContextRuntime;
+    };
+};
+export type ProjectOpenAiProcedureWorkflowRunnerOptions = {
+    tuttiHome: string;
+    projectId: ProjectId;
+    workspaceRoot: string;
+    promptsRoot?: string;
+    agentContext?: CodexAppServerAgentContextRuntime;
+    recordUsage?: ProviderUsageRecorder;
+};
+export declare function createOpenAiProcedureWorkflowRunner(options: OpenAiProcedureWorkflowRunnerOptions): ProcedureWorkflowRunner;
+export declare function resolveProjectOpenAiProcedureWorkflowRunner(options: ProjectOpenAiProcedureWorkflowRunnerOptions): ProcedureWorkflowRunnerResolution;
+//# sourceMappingURL=openai.d.ts.map

package/dist/control-plane/workflows/openai.js

@@ -0,0 +1,411 @@
+import { copyFileSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { extname, isAbsolute, join, relative, resolve } from "node:path";
+import { renderPromptTemplate } from "../../prompt-templates/index.js";
+import { createOpenAiStructuredOutputClient, runOpenAiStructuredOutput, } from "../../providers/openai/sdk-procedure-runner.js";
+import { readOpenAiApiKeyCredential } from "../../providers/openai/credential-store.js";
+import { resolveOpenAiProviderConfig, } from "../../providers/openai/provider-config.js";
+import { SCRATCHPAD_REFRESH_OUTPUT_SCHEMA, TASK_COMPILE_OUTPUT_SCHEMA, PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA, CONTEXT_SYNC_OUTPUT_SCHEMA, PROJECT_BRIEF_REFRESH_OUTPUT_SCHEMA, FOLLOW_UP_CHECK_OUTPUT_SCHEMA, REFERENCE_FILE_SUMMARY_OUTPUT_SCHEMA, isContextSyncWorkflowOutput, isFollowUpCheckStructuredOutput, isProjectBriefRefreshWorkflowOutput, isProjectContextBootstrapWorkflowOutput, isReferenceFileSummaryStructuredOutput, isScratchpadRefreshStructuredOutput, isTaskCompileStructuredOutput, } from "./structured-output.js";
+import { runCodexAppServerReadOnlyProcedure } from "../../providers/openai/app-server/read-only-procedure.js";
+function readOnlyAppServerOptions(options, prompt, outputSchema, skillSelectionName) {
+    if (options.readOnlyAppServer === undefined) {
+        throw new Error("Codex app-server read-only Procedure adapter is not configured");
+    }
+    return {
+        apiKey: options.readOnlyAppServer.apiKey,
+        workspaceRoot: options.readOnlyAppServer.workspaceRoot,
+        prompt,
+        outputSchema,
+        skillSelectionName,
+        defaultModel: options.config.default_model,
+        ...(options.config.api_base_url === undefined
+            ? {}
+            : { apiBaseUrl: options.config.api_base_url }),
+        ...(options.readOnlyAppServer.codexCommand === undefined
+            ? {}
+            : { codexCommand: options.readOnlyAppServer.codexCommand }),
+        ...(options.readOnlyAppServer.requestTimeoutMs === undefined
+            ? {}
+            : { requestTimeoutMs: options.readOnlyAppServer.requestTimeoutMs }),
+        ...(options.readOnlyAppServer.turnTimeoutMs === undefined
+            ? {}
+            : { turnTimeoutMs: options.readOnlyAppServer.turnTimeoutMs }),
+        ...(options.readOnlyAppServer.baseEnv === undefined
+            ? {}
+            : { baseEnv: options.readOnlyAppServer.baseEnv }),
+        ...(options.readOnlyAppServer.tuttiHome === undefined
+            ? {}
+            : { tuttiHome: options.readOnlyAppServer.tuttiHome }),
+        ...(options.readOnlyAppServer.builtInSkillsRoot === undefined
+            ? {}
+            : { builtInSkillsRoot: options.readOnlyAppServer.builtInSkillsRoot }),
+        ...(options.readOnlyAppServer.agentContext === undefined
+            ? {}
+            : { agentContext: options.readOnlyAppServer.agentContext }),
+    };
+}
+function referenceSummarySourcePath(options, input) {
+    if (options.readOnlyAppServer === undefined) {
+        throw new Error("Codex app-server read-only Procedure adapter is not configured");
+    }
+    const workspaceRoot = resolve(options.readOnlyAppServer.workspaceRoot);
+    const filePath = resolve(workspaceRoot, input.file.path);
+    const relativePath = relative(workspaceRoot, filePath);
+    if (relativePath === "" || relativePath.startsWith("..") || isAbsolute(relativePath)) {
+        throw new Error("Reference summary target must stay inside the workspace root");
+    }
+    return filePath;
+}
+function createReferenceSummaryWorkspace(input) {
+    const root = mkdtempSync(join(tmpdir(), "tutti-reference-summary-"));
+    const extension = extname(input.originalPath);
+    copyFileSync(input.sourcePath, join(root, `target${extension}`));
+    return {
+        cwd: root,
+        cleanup: () => rmSync(root, { recursive: true, force: true }),
+    };
+}
+function referenceFileSummaryWorkflowOutput(output, originalPath) {
+    if ("summarized" in output.result) {
+        return {
+            decision: "summarized",
+            summary: output.result.summarized.summary,
+            unavailable_reason: "",
+            read_paths: [originalPath],
+        };
+    }
+    return {
+        decision: "unavailable",
+        summary: "",
+        unavailable_reason: output.result.unavailable.reason,
+        read_paths: [originalPath],
+    };
+}
+function followUpCheckPromptInput(input) {
+    const submittedMessageRefs = new Set(input.submitted_message_refs);
+    const answers = input.round_messages
+        .filter((message) => message.author.kind === "human")
+        .filter((message) => submittedMessageRefs.size === 0 || submittedMessageRefs.has(message.id))
+        .map((message) => message.body.trim())
+        .filter((text) => text.length > 0);
+    return {
+        title: input.task_detail.task.title,
+        goal: input.task_detail.detail.contract.goal,
+        scope: input.task_detail.detail.contract.scope,
+        previous_run: {
+            summary: input.latest_run_result.summary,
+            clarification_request_payload: input.clarification_request_payload,
+        },
+        answers,
+    };
+}
+function followUpCheckWorkflowOutput(output) {
+    if ("resume" in output.result) {
+        return {
+            decision: "resume",
+            summary: output.result.resume.summary,
+        };
+    }
+    if ("needs_more_input" in output.result) {
+        return {
+            decision: "needs_more_input",
+            summary: output.result.needs_more_input.summary,
+            clarification_request_payload: output.result.needs_more_input,
+        };
+    }
+    return {
+        decision: "requires_retasking",
+        summary: output.result.requires_retasking.summary,
+    };
+}
+function taskCompilePromptInput(input) {
+    const promptInput = {
+        scratchpad: {
+            topic: input.scratchpad.topic,
+            background_summary: input.scratchpad.background_summary,
+            current_consensus: input.scratchpad.current_consensus,
+            open_questions: input.scratchpad.open_questions,
+            task_changes: input.scratchpad.task_changes,
+        },
+        worklist: {
+            modules: input.worklist.modules.map((entry) => ({
+                id: entry.module.id,
+                name: entry.module.name,
+                ...(entry.module.summary === undefined ? {} : { summary: entry.module.summary }),
+                archived: entry.module.archived,
+                tasks: entry.tasks.map((task) => ({
+                    title: task.title,
+                    summary: task.summary,
+                    status: task.status,
+                })),
+            })),
+        },
+    };
+    if (input.clarification !== undefined) {
+        const request = {
+            ...(input.clarification.request_payload.title === undefined
+                ? {}
+                : { title: input.clarification.request_payload.title }),
+            summary: input.clarification.request_payload.summary,
+            request: input.clarification.request_payload.request,
+        };
+        promptInput.clarification = {
+            request,
+            answer_messages: input.clarification.messages
+                .filter((message) => message.message_kind === "user_text" || message.message_kind === "agent_text")
+                .map(taskCompileClarificationMessage),
+        };
+    }
+    return promptInput;
+}
+function taskCompileClarificationMessage(message) {
+    const role = message.author.kind === "agent" ? "tutti" : "human";
+    const authorDisplayName = message.author.display_name?.trim();
+    return {
+        role,
+        ...(role === "human" && authorDisplayName !== undefined && authorDisplayName !== ""
+            ? { author_display_name: authorDisplayName }
+            : {}),
+        text: message.body.trim(),
+    };
+}
+function taskCompileWorkflowOutput(output) {
+    if ("clarification_request_payload" in output.result) {
+        return {
+            decision: "needs_human",
+            clarification_request_payload: output.result.clarification_request_payload,
+        };
+    }
+    return {
+        decision: "ready",
+        proposal: {
+            modules: output.result.proposal.modules,
+            tasks: output.result.proposal.tasks.map((task) => ({
+                title: task.title,
+                summary: task.goal,
+                contract: {
+                    goal: task.goal,
+                    scope: task.scope,
+                },
+                ...(task.module_ref.kind === "new"
+                    ? { module_temp_key: task.module_ref.key }
+                    : { existing_module_key: task.module_ref.key }),
+            })),
+        },
+    };
+}
+function recordUsage(options, source, result, anchors = {}) {
+    if (options.recordUsage === undefined || result.usage === undefined) {
+        return;
+    }
+    options.recordUsage({
+        provider: "openai",
+        source,
+        model: result.model ?? options.config.default_model,
+        usage: result.usage,
+        ...anchors,
+    });
+}
+export function createOpenAiProcedureWorkflowRunner(options) {
+    const runner = {
+        async runScratchpadRefresh(input, context) {
+            const instructions = renderPromptTemplate({
+                templateKey: "procedures.scratchpad_refresh",
+                ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+                variables: {
+                    workflow_input_json: input,
+                },
+            });
+            const result = await runOpenAiStructuredOutput({
+                client: options.client,
+                model: options.config.default_model,
+                instructions,
+                input: "Run scratchpad_refresh and return only structured JSON.",
+                schemaName: "scratchpad_refresh_output",
+                schemaDescription: "Tutti scratchpad_refresh terminal workflow output.",
+                schema: SCRATCHPAD_REFRESH_OUTPUT_SCHEMA,
+                validate: isScratchpadRefreshStructuredOutput,
+            });
+            recordUsage(options, "scratchpad_refresh", result, {
+                workflow_ref: context.workflow_ref,
+                activity_ref: context.activity_ref,
+            });
+            return result.output.result;
+        },
+        async runProjectBriefRefresh(input, context) {
+            const instructions = renderPromptTemplate({
+                templateKey: "procedures.project_brief_refresh",
+                ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+                variables: {
+                    workflow_input_json: input,
+                },
+            });
+            const result = await runOpenAiStructuredOutput({
+                client: options.client,
+                model: options.config.default_model,
+                instructions,
+                input: "Run project_brief_refresh and return only structured JSON.",
+                schemaName: "project_brief_refresh_output",
+                schemaDescription: "Tutti Project Brief refresh output.",
+                schema: PROJECT_BRIEF_REFRESH_OUTPUT_SCHEMA,
+                validate: isProjectBriefRefreshWorkflowOutput,
+            });
+            recordUsage(options, "project_brief_refresh", result, {
+                ...(context?.workflow_ref === undefined ? {} : { workflow_ref: context.workflow_ref }),
+                ...(context?.activity_ref === undefined ? {} : { activity_ref: context.activity_ref }),
+            });
+            return result.output;
+        },
+        async runTaskCompile(input, context) {
+            const instructions = renderPromptTemplate({
+                templateKey: "procedures.task_compile",
+                ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+                variables: {
+                    workflow_input_json: taskCompilePromptInput(input),
+                },
+            });
+            const result = await runCodexAppServerReadOnlyProcedure({
+                ...readOnlyAppServerOptions(options, instructions, TASK_COMPILE_OUTPUT_SCHEMA, "task_compile"),
+                validateOutput: isTaskCompileStructuredOutput,
+                networkAccess: false,
+                webSearchMode: "disabled",
+            });
+            recordUsage(options, "task_compile", result, {
+                workflow_ref: context?.workflow_ref ?? input.workflow_ref,
+                ...(context?.activity_ref === undefined ? {} : { activity_ref: context.activity_ref }),
+            });
+            return taskCompileWorkflowOutput(result.output);
+        },
+        async runFollowUpCheck(input, context) {
+            const instructions = renderPromptTemplate({
+                templateKey: "procedures.follow_up_check",
+                ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+                variables: {
+                    workflow_input_json: followUpCheckPromptInput(input),
+                },
+            });
+            const result = await runOpenAiStructuredOutput({
+                client: options.client,
+                model: options.config.default_model,
+                instructions,
+                input: "Run follow_up_check and return only structured JSON.",
+                schemaName: "follow_up_check_output",
+                schemaDescription: "Tutti follow_up_check terminal workflow output.",
+                schema: FOLLOW_UP_CHECK_OUTPUT_SCHEMA,
+                validate: isFollowUpCheckStructuredOutput,
+            });
+            recordUsage(options, "follow_up_check", result, {
+                workflow_ref: context?.workflow_ref ?? input.workflow_ref,
+                ...(context?.activity_ref === undefined ? {} : { activity_ref: context.activity_ref }),
+                task_id: input.task_id,
+                run_lineage_kind: input.run_lineage.kind,
+            });
+            return followUpCheckWorkflowOutput(result.output);
+        },
+    };
+    if (options.readOnlyAppServer !== undefined) {
+        runner.runProjectContextBootstrap = async (input, context) => {
+            const instructions = renderPromptTemplate({
+                templateKey: "procedures.project_context_bootstrap",
+                ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+                variables: {
+                    workflow_input_json: input,
+                },
+            });
+            const result = await runCodexAppServerReadOnlyProcedure({
+                ...readOnlyAppServerOptions(options, instructions, PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA, "project_context_bootstrap"),
+                validateOutput: isProjectContextBootstrapWorkflowOutput,
+            });
+            recordUsage(options, "project_context_bootstrap", result, {
+                ...(context?.workflow_ref === undefined ? {} : { workflow_ref: context.workflow_ref }),
+                ...(context?.activity_ref === undefined ? {} : { activity_ref: context.activity_ref }),
+            });
+            return result.output;
+        };
+        runner.runContextSync = async (input, context) => {
+            const instructions = renderPromptTemplate({
+                templateKey: "procedures.context_sync",
+                ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+            });
+            const result = await runCodexAppServerReadOnlyProcedure({
+                ...readOnlyAppServerOptions(options, instructions, CONTEXT_SYNC_OUTPUT_SCHEMA, "context_sync"),
+                validateOutput: isContextSyncWorkflowOutput,
+            });
+            recordUsage(options, "context_sync", result, {
+                workflow_ref: context?.workflow_ref ?? input.workflow_ref,
+                activity_ref: context?.activity_ref ?? input.activity_ref,
+            });
+            return result.output;
+        };
+        runner.runReferenceFileSummary = async (input, context) => {
+            const sourcePath = referenceSummarySourcePath(options, input);
+            const instructions = renderPromptTemplate({
+                templateKey: "procedures.reference_file_summary",
+                ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+            });
+            const workspace = createReferenceSummaryWorkspace({
+                sourcePath,
+                originalPath: input.file.path,
+            });
+            try {
+                const result = await runCodexAppServerReadOnlyProcedure({
+                    ...readOnlyAppServerOptions(options, instructions, REFERENCE_FILE_SUMMARY_OUTPUT_SCHEMA, "reference_summary_refresh"),
+                    appServerCwd: workspace.cwd,
+                    validateOutput: isReferenceFileSummaryStructuredOutput,
+                    readablePaths: [workspace.cwd],
+                    networkAccess: false,
+                    webSearchMode: "disabled",
+                });
+                recordUsage(options, "reference_summary_refresh", result, {
+                    workflow_ref: context?.workflow_ref ?? input.workflow_ref,
+                    activity_ref: context?.activity_ref ?? input.activity_ref,
+                });
+                return referenceFileSummaryWorkflowOutput(result.output, input.file.path);
+            }
+            finally {
+                workspace.cleanup();
+            }
+        };
+    }
+    return runner;
+}
+export function resolveProjectOpenAiProcedureWorkflowRunner(options) {
+    const resolution = resolveOpenAiProviderConfig({
+        tuttiHome: options.tuttiHome,
+        projectId: options.projectId,
+    });
+    if (resolution.kind === "unavailable") {
+        return { kind: "not_configured" };
+    }
+    const config = resolution.config;
+    let credential;
+    try {
+        credential = readOpenAiApiKeyCredential(options.tuttiHome, options.projectId, config.credential_ref);
+    }
+    catch {
+        return { kind: "not_configured" };
+    }
+    return {
+        kind: "ready",
+        runner: createOpenAiProcedureWorkflowRunner({
+            config,
+            ...(options.promptsRoot === undefined ? {} : { promptsRoot: options.promptsRoot }),
+            client: createOpenAiStructuredOutputClient({
+                apiKey: credential.secret,
+                ...(config.api_base_url === undefined ? {} : { apiBaseUrl: config.api_base_url }),
+                ...(config.organization_id === undefined ? {} : { organizationId: config.organization_id }),
+                ...(config.openai_project_id === undefined
+                    ? {}
+                    : { openAiProjectId: config.openai_project_id }),
+            }),
+            readOnlyAppServer: {
+                apiKey: credential.secret,
+                workspaceRoot: options.workspaceRoot,
+                tuttiHome: options.tuttiHome,
+                ...(options.agentContext === undefined ? {} : { agentContext: options.agentContext }),
+            },
+            ...(options.recordUsage === undefined ? {} : { recordUsage: options.recordUsage }),
+        }),
+    };
+}
+//# sourceMappingURL=openai.js.map

package/dist/control-plane/workflows/structured-output-schemas.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAiJsonSchema } from "../../providers/openai/sdk-procedure-runner.js";
+export declare const SCRATCHPAD_REFRESH_OUTPUT_SCHEMA: OpenAiJsonSchema;
+export declare const TASK_COMPILE_OUTPUT_SCHEMA: OpenAiJsonSchema;
+export declare const PROJECT_CONTEXT_BOOTSTRAP_OUTPUT_SCHEMA: OpenAiJsonSchema;
+export declare const CONTEXT_SYNC_OUTPUT_SCHEMA: OpenAiJsonSchema;
+export declare const PROJECT_BRIEF_REFRESH_OUTPUT_SCHEMA: OpenAiJsonSchema;
+export declare const REFERENCE_FILE_SUMMARY_OUTPUT_SCHEMA: OpenAiJsonSchema;
+export declare const FOLLOW_UP_CHECK_OUTPUT_SCHEMA: OpenAiJsonSchema;
+//# sourceMappingURL=structured-output-schemas.d.ts.map