opencode

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
101
102
103
104
105
106
107
108
109
110// Provider state and boundary schemas. Output types come directly from
// the Convergence agent protocol; OpenCode's own shapes stay `unknown`
// until the mapper reads them.
import * as z from "zod";
import type { AgentEvent, PromptDelivery, RunOutcome } from "convergence/protocol";
import type * as Deferred from "effect/Deferred";
import type * as Fiber from "effect/Fiber";

export type {
  ConfigChoice as Choice,
  ConfigOption,
  ToolContent,
  ToolCall,
  QuestionOption,
  QuestionField,
  TaskInfo as Task,
  Usage,
  TranscriptItem,
  AgentInfo,
} from "convergence/protocol";

export type { AgentEvent as Event } from "convergence/protocol";
export type { Instance } from "./instances.ts";

/// A chat the host knows: its folder, the options it chose, the model its
/// last turn ran on, and the plugin tools and instructions it was created
/// with.
export interface SessionState {
  workspace: string;
  options: Record<string, unknown>;
  ranOn: [string, string] | null;
  tools: { name: string; description?: string; inputSchema?: unknown }[];
  instructions: string | null;
}

/// An active run: its id, the error it reported (if any), and when the
/// prompt was sent (so a reconnect can tell a lost idle from a new turn).
export interface RunState {
  id: string;
  error: string | null;
  startedAt?: number;
  delivery?: PromptDelivery & { nativeInputId: string; consumed: boolean };
  stopping?: boolean;
  outcome?: RunOutcome;
}

/// One workspace folder's event-stream subscription.
export interface StreamEntry {
  stopped: boolean;
  body: { cancel?: () => unknown; end?: () => unknown } | null;
  fiber: Fiber.Fiber<void> | null;
  ready: Deferred.Deferred<void>;
  droppedAt?: number | null;
}

const sessionSchema = z.looseObject({
  sessionId: z.string().optional(),
  workspace: z.string().optional(),
  options: z.record(z.string(), z.unknown()).optional(),
  tools: z
    .array(z.object({ name: z.string(), description: z.string().optional(), inputSchema: z.unknown().optional() }))
    .optional(),
  instructions: z.string().nullish(),
});

const promptBlock = 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(),
});

export const promptSchema = z.object({
  itemId: z.string().optional(),
  blocks: z.array(promptBlock).optional(),
  delivery: z
    .object({ inputId: z.string(), attemptId: z.string(), intent: z.enum(["send", "steer", "queue"]) })
    .optional(),
});

export type PromptInput = z.infer<typeof promptSchema>;

const answerSchema = z.object({
  cancelled: z.boolean().optional(),
  values: z.record(z.string(), z.unknown()).optional(),
});

export type QuestionInput = z.infer<typeof answerSchema>;

export const schemas = {
  session: z.object({ sessionId: z.string() }),
  workspace: z.object({ workspace: z.string().optional() }),
  skills: z.object({ workspace: z.string() }),
  create: sessionSchema,
  resume: sessionSchema.extend({ sessionId: z.string() }),
  prompt: z.object({ sessionId: z.string(), input: promptSchema.optional() }),
  cancelTask: z.object({ sessionId: z.string(), taskId: z.string() }),
  setOption: z.object({ sessionId: z.string(), optionId: z.string(), value: z.unknown() }),
  approval: z.object({ approvalId: z.string(), optionId: z.string() }),
  question: z.object({ questionId: z.string(), answer: answerSchema.optional() }),
  rollback: z.object({ sessionId: z.string(), itemId: z.string() }),
  fork: sessionSchema.extend({ sessionId: z.string() }),
  authenticate: z.object({ method: z.unknown().optional() }),
  empty: z.unknown(),
};

export type SessionParams = z.infer<typeof sessionSchema>;