codex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100// Provider state and boundary schemas. Output types come directly from
// the Convergence agent protocol; app-server input types live in wire.ts.
import * as z from "zod";
import type * as Deferred from "effect/Deferred";
import type { Thread, Turn } from "./wire.ts";

export type {
  ConfigChoice as Choice,
  ConfigOption,
  ToolContent,
  ToolCall,
  QuestionOption,
  QuestionField,
  TaskInfo as Task,
  Usage,
  UsageWindow,
  UsageLimits,
  TranscriptItem,
  AgentInfo,
} from "convergence/protocol";
import type { TaskInfo as Task, Usage } from "convergence/protocol";
export const answerSchema = z.object({
  cancelled: z.boolean().optional(),
  values: z
    .record(z.string(), z.union([z.string(), z.boolean(), z.number(), z.array(z.string()), z.null()]))
    .optional(),
});
export type QuestionAnswer = z.infer<typeof answerSchema>;
export interface History {
  thread: Thread;
  turns: Turn[];
}
export interface Facts {
  toolCallId?: string | null;
  prompt?: string | null;
  model?: string | null;
  effort?: string | null;
  name?: string | null;
  taskName?: string | null;
  startedAt?: string | null;
}
export interface Session {
  workspace: string;
  options: Record<string, unknown>;
  run: string | null;
  turn: string | null;
  starting?: Deferred.Deferred<string | null>;
  inputs: Map<string, { inputId: string; attemptId: string; runId: string }>;
  endedTurns: Set<string>;
  turns: Map<string, string>;
  streamed: Set<string>;
  startedTools: Set<string>;
  held: Map<string, string>;
  unloaded?: boolean;
}
export interface Child {
  root: string;
  turn: string | null;
  endedTurns: Set<string>;
  task: Task;
  taskName: string | null;
  tools: Set<string>;
  streamed: Set<string>;
  held: Map<string, string>;
}
export type { AgentEvent as Event } from "convergence/protocol";
export const sessionSchema = z.looseObject({
  workspace: z.string().optional(),
  options: z.record(z.string(), z.unknown()).optional(),
  instructions: z.string().optional(),
  tools: z
    .array(z.object({ name: z.string(), description: z.string().nullish(), inputSchema: z.unknown().optional() }))
    .optional(),
});
export interface SessionOptions {
  workspace?: string;
  options?: Record<string, unknown>;
  instructions?: string;
  tools?: { name: string; description?: string | null; inputSchema?: unknown }[];
}
export const promptSchema = z.object({
  itemId: z.string().optional(),
  delivery: z
    .object({ inputId: z.string(), attemptId: z.string(), intent: z.enum(["send", "steer", "queue"]) })
    .optional(),
  blocks: z
    .array(
      z.looseObject({
        type: z.string().optional(),
        text: z.string().optional(),
        path: z.string().optional(),
        mimeType: z.string().optional(),
        data: z.string().optional(),
        name: z.string().optional(),
        input: z.string().optional(),
      }),
    )
    .optional(),
});
export type PromptInput = z.infer<typeof promptSchema>;