genaicode 2.33.0 → 2.35.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +1 -0
- package/dist/agents/artifacts.d.ts +1 -1
- package/dist/agents/artifacts.js +4 -65
- package/dist/agents/artifacts.js.map +1 -1
- package/dist/agents/cli-agent.d.ts +3 -0
- package/dist/agents/cli-agent.js +1 -0
- package/dist/agents/cli-agent.js.map +1 -1
- package/dist/agents/drivers/anthropic-managed.d.ts +145 -0
- package/dist/agents/drivers/anthropic-managed.js +799 -0
- package/dist/agents/drivers/anthropic-managed.js.map +1 -0
- package/dist/agents/drivers/antigravity.js +2 -0
- package/dist/agents/drivers/antigravity.js.map +1 -1
- package/dist/agents/drivers/claude.js +2 -0
- package/dist/agents/drivers/claude.js.map +1 -1
- package/dist/agents/drivers/codex-live.js +2 -0
- package/dist/agents/drivers/codex-live.js.map +1 -1
- package/dist/agents/drivers/codex.js +2 -0
- package/dist/agents/drivers/codex.js.map +1 -1
- package/dist/agents/drivers/copilot.js +2 -0
- package/dist/agents/drivers/copilot.js.map +1 -1
- package/dist/agents/drivers/cursor-cloud.d.ts +78 -0
- package/dist/agents/drivers/cursor-cloud.js +523 -0
- package/dist/agents/drivers/cursor-cloud.js.map +1 -0
- package/dist/agents/drivers/cursor.js +2 -0
- package/dist/agents/drivers/cursor.js.map +1 -1
- package/dist/agents/drivers/gemini-managed.d.ts +78 -0
- package/dist/agents/drivers/gemini-managed.js +528 -0
- package/dist/agents/drivers/gemini-managed.js.map +1 -0
- package/dist/agents/drivers/gemini.js +2 -0
- package/dist/agents/drivers/gemini.js.map +1 -1
- package/dist/agents/drivers/managed-http.d.ts +28 -0
- package/dist/agents/drivers/managed-http.js +142 -0
- package/dist/agents/drivers/managed-http.js.map +1 -0
- package/dist/agents/drivers/muse-live.js +2 -0
- package/dist/agents/drivers/muse-live.js.map +1 -1
- package/dist/agents/drivers/muse.js +2 -0
- package/dist/agents/drivers/muse.js.map +1 -1
- package/dist/agents/drivers/openai-managed.d.ts +79 -0
- package/dist/agents/drivers/openai-managed.js +404 -0
- package/dist/agents/drivers/openai-managed.js.map +1 -0
- package/dist/agents/drivers/opencode.js +2 -0
- package/dist/agents/drivers/opencode.js.map +1 -1
- package/dist/agents/drivers/vibe.js +2 -0
- package/dist/agents/drivers/vibe.js.map +1 -1
- package/dist/agents/failover.d.ts +19 -1
- package/dist/agents/failover.js +63 -2
- package/dist/agents/failover.js.map +1 -1
- package/dist/agents/hosted.d.ts +5 -1
- package/dist/agents/hosted.js +47 -132
- package/dist/agents/hosted.js.map +1 -1
- package/dist/agents/live-agent.d.ts +3 -0
- package/dist/agents/live-agent.js +1 -0
- package/dist/agents/live-agent.js.map +1 -1
- package/dist/agents/managed.d.ts +157 -0
- package/dist/agents/managed.js +562 -0
- package/dist/agents/managed.js.map +1 -0
- package/dist/agents/mcp-server.d.ts +19 -0
- package/dist/agents/mcp-server.js +74 -0
- package/dist/agents/mcp-server.js.map +1 -0
- package/dist/agents/pack-git.d.ts +23 -0
- package/dist/agents/pack-git.js +112 -0
- package/dist/agents/pack-git.js.map +1 -0
- package/dist/agents/pack.d.ts +68 -0
- package/dist/agents/pack.js +611 -0
- package/dist/agents/pack.js.map +1 -0
- package/dist/agents/runtime.d.ts +5 -1
- package/dist/agents/runtime.js +9 -0
- package/dist/agents/runtime.js.map +1 -1
- package/dist/agents/session.d.ts +10 -0
- package/dist/agents/session.js +26 -0
- package/dist/agents/session.js.map +1 -1
- package/dist/agents/sessions/claude.d.ts +14 -0
- package/dist/agents/sessions/claude.js +233 -0
- package/dist/agents/sessions/claude.js.map +1 -0
- package/dist/agents/sessions/codex-api.d.ts +32 -0
- package/dist/agents/sessions/codex-api.js +233 -0
- package/dist/agents/sessions/codex-api.js.map +1 -0
- package/dist/agents/sessions/codex.d.ts +28 -0
- package/dist/agents/sessions/codex.js +430 -0
- package/dist/agents/sessions/codex.js.map +1 -0
- package/dist/agents/sessions/doctor.d.ts +67 -0
- package/dist/agents/sessions/doctor.js +182 -0
- package/dist/agents/sessions/doctor.js.map +1 -0
- package/dist/agents/sessions/files.d.ts +44 -0
- package/dist/agents/sessions/files.js +150 -0
- package/dist/agents/sessions/files.js.map +1 -0
- package/dist/agents/sessions/group.d.ts +24 -0
- package/dist/agents/sessions/group.js +27 -0
- package/dist/agents/sessions/group.js.map +1 -0
- package/dist/agents/sessions/hooks.d.ts +32 -0
- package/dist/agents/sessions/hooks.js +155 -0
- package/dist/agents/sessions/hooks.js.map +1 -0
- package/dist/agents/sessions/index.d.ts +42 -0
- package/dist/agents/sessions/index.js +97 -0
- package/dist/agents/sessions/index.js.map +1 -0
- package/dist/agents/sessions/live.d.ts +67 -0
- package/dist/agents/sessions/live.js +308 -0
- package/dist/agents/sessions/live.js.map +1 -0
- package/dist/agents/sessions/sqlite.d.ts +12 -0
- package/dist/agents/sessions/sqlite.js +61 -0
- package/dist/agents/sessions/sqlite.js.map +1 -0
- package/dist/agents/sessions/stores.d.ts +38 -0
- package/dist/agents/sessions/stores.js +616 -0
- package/dist/agents/sessions/stores.js.map +1 -0
- package/dist/agents/sessions/transcript.d.ts +20 -0
- package/dist/agents/sessions/transcript.js +134 -0
- package/dist/agents/sessions/transcript.js.map +1 -0
- package/dist/agents/sessions/types.d.ts +95 -0
- package/dist/agents/sessions/types.js +2 -0
- package/dist/agents/sessions/types.js.map +1 -0
- package/dist/agents/types.d.ts +31 -0
- package/dist/agents.d.ts +17 -1
- package/dist/agents.js +9 -1
- package/dist/agents.js.map +1 -1
- package/dist/backend/backend.d.ts +131 -0
- package/dist/backend/backend.js +773 -0
- package/dist/backend/backend.js.map +1 -0
- package/dist/backend/limiter.d.ts +34 -0
- package/dist/backend/limiter.js +76 -0
- package/dist/backend/limiter.js.map +1 -0
- package/dist/backend/node.d.ts +10 -0
- package/dist/backend/node.js +124 -0
- package/dist/backend/node.js.map +1 -0
- package/dist/backend/protocol.d.ts +98 -0
- package/dist/backend/protocol.js +2 -0
- package/dist/backend/protocol.js.map +1 -0
- package/dist/backend/seal.d.ts +7 -0
- package/dist/backend/seal.js +60 -0
- package/dist/backend/seal.js.map +1 -0
- package/dist/backend.d.ts +27 -0
- package/dist/backend.js +25 -0
- package/dist/backend.js.map +1 -0
- package/dist/browser/invoke.d.ts +17 -0
- package/dist/browser/invoke.js +69 -0
- package/dist/browser/invoke.js.map +1 -0
- package/dist/browser/nano.d.ts +10 -0
- package/dist/browser/nano.js +10 -56
- package/dist/browser/nano.js.map +1 -1
- package/dist/browser/page-agent.d.ts +7 -0
- package/dist/browser/page-agent.js +26 -5
- package/dist/browser/page-agent.js.map +1 -1
- package/dist/browser/remote.d.ts +44 -0
- package/dist/browser/remote.js +372 -0
- package/dist/browser/remote.js.map +1 -0
- package/dist/browser.d.ts +9 -2
- package/dist/browser.js +8 -2
- package/dist/browser.js.map +1 -1
- package/dist/cli/args.d.ts +26 -0
- package/dist/cli/args.js +66 -0
- package/dist/cli/args.js.map +1 -1
- package/dist/cli/hook.d.ts +7 -0
- package/dist/cli/hook.js +21 -0
- package/dist/cli/hook.js.map +1 -0
- package/dist/cli/main.d.ts +3 -1
- package/dist/cli/main.js +237 -2
- package/dist/cli/main.js.map +1 -1
- package/dist/cli.js +31 -21
- package/dist/cli.js.map +1 -1
- package/dist/core/types.d.ts +5 -0
- package/dist/core/types.js.map +1 -1
- package/dist/index.d.ts +1 -1
- package/dist/index.js +1 -1
- package/dist/index.js.map +1 -1
- package/dist/providers/google-converter.js +21 -8
- package/dist/providers/google-converter.js.map +1 -1
- package/dist/providers/google.js +7 -10
- package/dist/providers/google.js.map +1 -1
- package/dist/providers/openai-converter.js +3 -2
- package/dist/providers/openai-converter.js.map +1 -1
- package/dist/providers/openai-responses-converter.d.ts +35 -0
- package/dist/providers/openai-responses-converter.js +188 -0
- package/dist/providers/openai-responses-converter.js.map +1 -0
- package/dist/providers/openai.d.ts +6 -1
- package/dist/providers/openai.js +16 -1
- package/dist/providers/openai.js.map +1 -1
- package/dist/providers.d.ts +1 -0
- package/dist/providers.js +1 -0
- package/dist/providers.js.map +1 -1
- package/dist/react/page-agent-chat.js +6 -2
- package/dist/react/page-agent-chat.js.map +1 -1
- package/dist/ui/index.js +109 -82
- package/dist/ui/sessions.d.ts +19 -0
- package/dist/ui/sessions.js +59 -0
- package/dist/ui/sessions.js.map +1 -0
- package/dist/ui/web-client.js +15 -14
- package/docs/CHANGELOG.md +51 -388
- package/docs/agents.md +417 -2
- package/docs/backend.md +125 -0
- package/docs/browser.md +6 -1
- package/docs/changelog-2.26-and-older.md +441 -0
- package/docs/cli.md +39 -0
- package/docs/llm.md +6 -1
- package/docs/pivot.md +1 -1
- package/package.json +5 -1
|
@@ -0,0 +1,799 @@
|
|
|
1
|
+
import { posix } from 'node:path';
|
|
2
|
+
import { failureOfError, managedAgent, } from '../managed.js';
|
|
3
|
+
import { anySignal } from '../runtime.js';
|
|
4
|
+
/** `sessions.list` reads at most this many sessions. */
|
|
5
|
+
const MAX_LISTED = 1000;
|
|
6
|
+
const EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max'];
|
|
7
|
+
/** Claude Managed Agents as a `CodingAgent`: sessions on Anthropic's agent loop and sandbox. */
|
|
8
|
+
export function anthropicManaged(options) {
|
|
9
|
+
return managedAgent(anthropicManagedProvider(options), {
|
|
10
|
+
...(options.pollIntervalMs !== undefined ? { pollIntervalMs: options.pollIntervalMs } : {}),
|
|
11
|
+
});
|
|
12
|
+
}
|
|
13
|
+
/** Claude Managed Agents as a `ManagedProvider`. */
|
|
14
|
+
export function anthropicManagedProvider(options) {
|
|
15
|
+
const name = options.name ?? 'anthropicManaged';
|
|
16
|
+
const agentRef = typeof options.agent === 'string' ? { id: options.agent } : options.agent;
|
|
17
|
+
let clientPromise;
|
|
18
|
+
const client = () => (clientPromise ??= options.client ? Promise.resolve(options.client) : defaultClient());
|
|
19
|
+
const retrieve = async (id, signal) => {
|
|
20
|
+
try {
|
|
21
|
+
return await (await client()).beta.sessions.retrieve(id, undefined, signal ? { signal } : undefined);
|
|
22
|
+
}
|
|
23
|
+
catch (error) {
|
|
24
|
+
if (statusOf(error) === 404)
|
|
25
|
+
return null;
|
|
26
|
+
throw error;
|
|
27
|
+
}
|
|
28
|
+
};
|
|
29
|
+
/** Recent events, newest first, until `stop` says enough. */
|
|
30
|
+
const recent = async (id, stop, signal) => {
|
|
31
|
+
const c = await client();
|
|
32
|
+
let seen = 0;
|
|
33
|
+
for await (const event of c.beta.sessions.events.list(id, { order: 'desc', limit: 50 }, signal ? { signal } : undefined)) {
|
|
34
|
+
if (stop(event) || ++seen >= 200)
|
|
35
|
+
return event;
|
|
36
|
+
}
|
|
37
|
+
return undefined;
|
|
38
|
+
};
|
|
39
|
+
/** Events after `cursor`, oldest first. */
|
|
40
|
+
async function* after(id, cursor, signal) {
|
|
41
|
+
const c = await client();
|
|
42
|
+
const at = parseCursor(cursor);
|
|
43
|
+
const params = { order: 'asc', ...(at ? { 'created_at[gte]': at.time } : {}) };
|
|
44
|
+
// Events at the cursor's own instant: drop up to the cursor's event, keep the rest.
|
|
45
|
+
let held = [];
|
|
46
|
+
let holding = !!at;
|
|
47
|
+
for await (const event of c.beta.sessions.events.list(id, params, { signal })) {
|
|
48
|
+
if (holding && at && event.processed_at === at.time) {
|
|
49
|
+
if (event.id === at.id) {
|
|
50
|
+
held = [];
|
|
51
|
+
holding = false;
|
|
52
|
+
}
|
|
53
|
+
else
|
|
54
|
+
held.push(event);
|
|
55
|
+
continue;
|
|
56
|
+
}
|
|
57
|
+
if (holding) {
|
|
58
|
+
for (const event of held)
|
|
59
|
+
yield event;
|
|
60
|
+
held = [];
|
|
61
|
+
holding = false;
|
|
62
|
+
}
|
|
63
|
+
yield event;
|
|
64
|
+
}
|
|
65
|
+
for (const event of held)
|
|
66
|
+
yield event;
|
|
67
|
+
}
|
|
68
|
+
const snapshotOf = (session, extra = {}) => {
|
|
69
|
+
const usage = usageOf(session.usage);
|
|
70
|
+
const cost = session.usage?.list_cost;
|
|
71
|
+
const created = session.created_at ? Date.parse(session.created_at) : NaN;
|
|
72
|
+
return {
|
|
73
|
+
id: session.id,
|
|
74
|
+
state: 'running',
|
|
75
|
+
vendorState: session.status,
|
|
76
|
+
...(session.agent?.model?.id ? { model: session.agent.model.id } : {}),
|
|
77
|
+
...(usage ? { usage } : {}),
|
|
78
|
+
...(cost && cost.currency === 'USD' && /^\d+$/.test(cost.amount) ? { costUsd: Number(cost.amount) / 100 } : {}),
|
|
79
|
+
...(Number.isFinite(created) ? { startedAt: created } : {}),
|
|
80
|
+
...extra,
|
|
81
|
+
};
|
|
82
|
+
};
|
|
83
|
+
// The sessions of this driver's agent, as the API lists them (newest first by creation).
|
|
84
|
+
const sessions = {
|
|
85
|
+
name,
|
|
86
|
+
where: 'cloud',
|
|
87
|
+
async list(query = {}) {
|
|
88
|
+
// A local directory names no hosted session.
|
|
89
|
+
if (query.cwd !== undefined)
|
|
90
|
+
return [];
|
|
91
|
+
const c = await client();
|
|
92
|
+
if (!c.beta.sessions.list)
|
|
93
|
+
throw new Error(`${name}: this @anthropic-ai/sdk version cannot list sessions.`);
|
|
94
|
+
const wanted = query.limit ?? Infinity;
|
|
95
|
+
const found = [];
|
|
96
|
+
let seen = 0;
|
|
97
|
+
for await (const session of c.beta.sessions.list({ agent_id: agentRef.id, limit: 100 }, query.signal ? { signal: query.signal } : undefined)) {
|
|
98
|
+
if (++seen > MAX_LISTED)
|
|
99
|
+
break;
|
|
100
|
+
const snapshot = snapshotOf(session);
|
|
101
|
+
const updated = Date.parse(session.updated_at ?? session.created_at ?? '');
|
|
102
|
+
if (!Number.isFinite(updated) || (query.since !== undefined && updated < query.since))
|
|
103
|
+
continue;
|
|
104
|
+
const state = session.status === 'running' || session.status === 'rescheduling'
|
|
105
|
+
? 'active'
|
|
106
|
+
: session.status === 'idle'
|
|
107
|
+
? 'waiting'
|
|
108
|
+
: undefined;
|
|
109
|
+
found.push({
|
|
110
|
+
source: name,
|
|
111
|
+
agent: name,
|
|
112
|
+
id: session.id,
|
|
113
|
+
where: 'cloud',
|
|
114
|
+
updatedAt: updated,
|
|
115
|
+
...(snapshot.startedAt !== undefined ? { startedAt: snapshot.startedAt } : {}),
|
|
116
|
+
...(session.title ? { title: session.title } : {}),
|
|
117
|
+
...(snapshot.model ? { model: snapshot.model } : {}),
|
|
118
|
+
...(snapshot.usage ? { usage: snapshot.usage } : {}),
|
|
119
|
+
...(snapshot.costUsd !== undefined ? { costUsd: snapshot.costUsd } : {}),
|
|
120
|
+
...(state ? { state } : {}),
|
|
121
|
+
});
|
|
122
|
+
}
|
|
123
|
+
return found.sort((a, b) => b.updatedAt - a.updatedAt).slice(0, wanted);
|
|
124
|
+
},
|
|
125
|
+
};
|
|
126
|
+
/** The terminal error of the session's last turn, read back from its latest events. */
|
|
127
|
+
const turnError = async (id, signal) => {
|
|
128
|
+
let stopped = false;
|
|
129
|
+
let found;
|
|
130
|
+
await recent(id, (event) => {
|
|
131
|
+
// From the newest stop back to where that turn began.
|
|
132
|
+
if (!stopped) {
|
|
133
|
+
stopped = SESSION_STOPS.has(event.type);
|
|
134
|
+
return false;
|
|
135
|
+
}
|
|
136
|
+
if (event.type === 'session.error') {
|
|
137
|
+
const error = sessionError(event);
|
|
138
|
+
if (error.terminal)
|
|
139
|
+
found = error;
|
|
140
|
+
return !!found;
|
|
141
|
+
}
|
|
142
|
+
return TURN_STARTS.has(event.type);
|
|
143
|
+
}, signal);
|
|
144
|
+
return found;
|
|
145
|
+
};
|
|
146
|
+
/** The state of a session at rest, read from its latest events. */
|
|
147
|
+
const settledSnapshot = async (session, signal) => {
|
|
148
|
+
if (session.status === 'running')
|
|
149
|
+
return snapshotOf(session, { state: 'running' });
|
|
150
|
+
if (session.status === 'rescheduling')
|
|
151
|
+
return snapshotOf(session, { state: 'running' });
|
|
152
|
+
let error;
|
|
153
|
+
let idle;
|
|
154
|
+
let pending = false;
|
|
155
|
+
await recent(session.id, (event) => {
|
|
156
|
+
if (event.type === 'session.error' && (idle || session.status === 'terminated'))
|
|
157
|
+
error ??= sessionError(event);
|
|
158
|
+
if (event.type === 'user.message' && session.status === 'idle' && !idle)
|
|
159
|
+
pending = true;
|
|
160
|
+
// An ended session: its errors come before the end, back to where its last turn started.
|
|
161
|
+
if (session.status === 'terminated')
|
|
162
|
+
return event.type === 'session.status_running' || event.type === 'session.status_idle';
|
|
163
|
+
if (pending)
|
|
164
|
+
return true;
|
|
165
|
+
// Past the last idle, back to where its turn ran: the errors that explain it lie between.
|
|
166
|
+
if (idle)
|
|
167
|
+
return event.type === 'session.status_running' || event.type === 'user.message';
|
|
168
|
+
if (event.type === 'session.status_idle')
|
|
169
|
+
idle = event;
|
|
170
|
+
return false;
|
|
171
|
+
}, signal);
|
|
172
|
+
if (session.status === 'terminated') {
|
|
173
|
+
const failed = error?.terminal;
|
|
174
|
+
return snapshotOf(session, {
|
|
175
|
+
state: failed ? 'failed' : 'completed',
|
|
176
|
+
...(failed ? { error: error.message, ...(error.failure ? { failure: error.failure } : {}) } : {}),
|
|
177
|
+
endedAt: Date.now(),
|
|
178
|
+
});
|
|
179
|
+
}
|
|
180
|
+
// A message sent after the last idle: the next turn is about to start.
|
|
181
|
+
if (pending || !idle)
|
|
182
|
+
return snapshotOf(session, { state: 'queued' });
|
|
183
|
+
return snapshotOf(session, { state: 'idle', ...stopOf(idle, error) });
|
|
184
|
+
};
|
|
185
|
+
const provider = {
|
|
186
|
+
name,
|
|
187
|
+
sessions,
|
|
188
|
+
capabilities: {
|
|
189
|
+
usage: true,
|
|
190
|
+
mcp: true,
|
|
191
|
+
resume: true,
|
|
192
|
+
files: true,
|
|
193
|
+
effort: EFFORTS,
|
|
194
|
+
budget: ['usd'],
|
|
195
|
+
permissions: { approval: ['ask', 'auto-approve', 'deny'] },
|
|
196
|
+
},
|
|
197
|
+
async start(request, signal) {
|
|
198
|
+
if (request.maxTurns !== undefined)
|
|
199
|
+
throw new Error(`${name} cannot cap turns (maxTurns).`);
|
|
200
|
+
if (request.extraArgs?.length)
|
|
201
|
+
throw new Error(`${name} takes no extra arguments.`);
|
|
202
|
+
const c = await client();
|
|
203
|
+
const opts = signal ? { signal } : undefined;
|
|
204
|
+
const budget = request.budget?.maxCostUsd !== undefined
|
|
205
|
+
? {
|
|
206
|
+
type: 'limit',
|
|
207
|
+
max_list_cost: {
|
|
208
|
+
amount: String(Math.max(1, Math.round(request.budget.maxCostUsd * 100))),
|
|
209
|
+
currency: 'USD',
|
|
210
|
+
},
|
|
211
|
+
}
|
|
212
|
+
: undefined;
|
|
213
|
+
const message = { type: 'user.message', content: [{ type: 'text', text: request.prompt }] };
|
|
214
|
+
if (request.resume !== undefined) {
|
|
215
|
+
const session = await retrieve(request.resume, signal);
|
|
216
|
+
if (!session)
|
|
217
|
+
throw new Error(`${name} session ${request.resume} does not exist.`);
|
|
218
|
+
refusedOnResume(name, session, request);
|
|
219
|
+
// The platform caps the whole session, and `managedAgent()` already added what it spent.
|
|
220
|
+
if (budget && session.budget)
|
|
221
|
+
await c.beta.sessions.update(session.id, { budget }, opts);
|
|
222
|
+
const latest = await recent(session.id, (event) => !!event.id && !!event.processed_at, signal);
|
|
223
|
+
const cursor = latest?.id && latest.processed_at ? formatCursor(latest.processed_at, latest.id) : undefined;
|
|
224
|
+
const events = [message];
|
|
225
|
+
if (request.system)
|
|
226
|
+
events.push({ type: 'system.message', content: [{ type: 'text', text: request.system }] });
|
|
227
|
+
await c.beta.sessions.events.send(session.id, { events }, opts);
|
|
228
|
+
return snapshotOf(session, { state: 'queued', ...(cursor ? { cursor } : {}), startedAt: Date.now() });
|
|
229
|
+
}
|
|
230
|
+
const release = [];
|
|
231
|
+
try {
|
|
232
|
+
const agent = await agentFor(c, agentRef, request, signal);
|
|
233
|
+
const credentials = bearers(name, request.mcpServers ?? []);
|
|
234
|
+
if (credentials.length) {
|
|
235
|
+
const vault = await c.beta.vaults.create({
|
|
236
|
+
display_name: `genaicode ${request.correlationId ?? 'session'}`.slice(0, 255),
|
|
237
|
+
metadata: { created_by: 'genaicode' },
|
|
238
|
+
}, opts);
|
|
239
|
+
release.push(`vault:${vault.id}`);
|
|
240
|
+
for (const { server, token } of credentials)
|
|
241
|
+
await c.beta.vaults.credentials.create(vault.id, { display_name: server.name, auth: { type: 'static_bearer', mcp_server_url: server.url, token } }, opts);
|
|
242
|
+
}
|
|
243
|
+
const resources = [];
|
|
244
|
+
for (const file of request.files ?? []) {
|
|
245
|
+
const path = posix.normalize(file.path);
|
|
246
|
+
if (path.startsWith('..') || posix.isAbsolute(path))
|
|
247
|
+
throw new Error(`${name}: file path '${file.path}' leaves the workspace.`);
|
|
248
|
+
const content = typeof file.content === 'string' ? file.content : new Uint8Array(file.content);
|
|
249
|
+
const uploaded = await c.beta.files.upload({ file: new File([content], posix.basename(path)) }, opts);
|
|
250
|
+
release.push(`file:${uploaded.id}`);
|
|
251
|
+
resources.push({
|
|
252
|
+
type: 'file',
|
|
253
|
+
file_id: uploaded.id,
|
|
254
|
+
mount_path: posix.join(options.filesRoot ?? '/workspace', path),
|
|
255
|
+
});
|
|
256
|
+
}
|
|
257
|
+
const repo = githubWorkspace(request.workspace);
|
|
258
|
+
if (repo) {
|
|
259
|
+
const token = typeof options.githubToken === 'function' ? await options.githubToken() : options.githubToken;
|
|
260
|
+
resources.push({
|
|
261
|
+
type: 'github_repository',
|
|
262
|
+
url: repo.url,
|
|
263
|
+
...(repo.branch ? { checkout: { type: 'branch', name: repo.branch } } : {}),
|
|
264
|
+
...(token ? { authorization_token: token } : {}),
|
|
265
|
+
});
|
|
266
|
+
}
|
|
267
|
+
const vaults = [
|
|
268
|
+
...(options.vaultIds ?? []),
|
|
269
|
+
...release.filter((ref) => ref.startsWith('vault:')).map((ref) => ref.slice(6)),
|
|
270
|
+
];
|
|
271
|
+
const session = await c.beta.sessions.create({
|
|
272
|
+
agent,
|
|
273
|
+
environment_id: options.environment,
|
|
274
|
+
initial_events: [message],
|
|
275
|
+
...(request.correlationId
|
|
276
|
+
? {
|
|
277
|
+
title: request.correlationId.slice(0, 255),
|
|
278
|
+
metadata: { correlation_id: request.correlationId.slice(0, 512) },
|
|
279
|
+
}
|
|
280
|
+
: {}),
|
|
281
|
+
...(budget ? { budget } : {}),
|
|
282
|
+
...(vaults.length ? { vault_ids: vaults } : {}),
|
|
283
|
+
...(resources.length ? { resources } : {}),
|
|
284
|
+
}, opts);
|
|
285
|
+
// Created with a message, the session starts running at once; every event so far is this run's.
|
|
286
|
+
return snapshotOf(session, {
|
|
287
|
+
state: 'queued',
|
|
288
|
+
release,
|
|
289
|
+
startedAt: snapshotOf(session).startedAt ?? Date.now(),
|
|
290
|
+
});
|
|
291
|
+
}
|
|
292
|
+
catch (error) {
|
|
293
|
+
// Nothing started: free what this attempt made, and report the original error.
|
|
294
|
+
await freeAll(c, release);
|
|
295
|
+
throw error;
|
|
296
|
+
}
|
|
297
|
+
},
|
|
298
|
+
async get(id, signal) {
|
|
299
|
+
const session = await retrieve(id, signal);
|
|
300
|
+
return session ? settledSnapshot(session, signal) : null;
|
|
301
|
+
},
|
|
302
|
+
async *watch(id, signal, cursor) {
|
|
303
|
+
const c = await client();
|
|
304
|
+
const local = new AbortController();
|
|
305
|
+
const both = anySignal([signal, local.signal]);
|
|
306
|
+
const tools = new Map();
|
|
307
|
+
let lastError;
|
|
308
|
+
const seen = new Set();
|
|
309
|
+
const answeredTools = new Set();
|
|
310
|
+
let position = cursor;
|
|
311
|
+
/** One event as an update; `done` once the session settled. */
|
|
312
|
+
const translate = async (event) => {
|
|
313
|
+
if (event.id && event.processed_at)
|
|
314
|
+
position = formatCursor(event.processed_at, event.id);
|
|
315
|
+
const at = position ? { cursor: position } : {};
|
|
316
|
+
const e = event;
|
|
317
|
+
switch (event.type) {
|
|
318
|
+
case 'event_delta': {
|
|
319
|
+
const delta = e.delta;
|
|
320
|
+
const text = delta?.content?.type === 'text' ? delta.content.text : undefined;
|
|
321
|
+
return text ? { update: { events: [{ type: 'text-delta', text }] } } : {};
|
|
322
|
+
}
|
|
323
|
+
case 'agent.message': {
|
|
324
|
+
const text = textOf(e.content);
|
|
325
|
+
return { update: { ...at, ...(text ? { events: [{ type: 'message', text }] } : {}) } };
|
|
326
|
+
}
|
|
327
|
+
case 'agent.tool_use':
|
|
328
|
+
case 'agent.mcp_tool_use':
|
|
329
|
+
case 'agent.custom_tool_use': {
|
|
330
|
+
const toolName = String(e.name ?? 'tool');
|
|
331
|
+
const shown = event.type === 'agent.mcp_tool_use' ? `${String(e.mcp_server_name)}.${toolName}` : toolName;
|
|
332
|
+
if (event.id)
|
|
333
|
+
tools.set(event.id, shown);
|
|
334
|
+
const events = [
|
|
335
|
+
{ type: 'tool-start', ...(event.id ? { id: event.id } : {}), name: shown, input: e.input },
|
|
336
|
+
];
|
|
337
|
+
if (event.type !== 'agent.custom_tool_use' &&
|
|
338
|
+
e.evaluated_permission === 'ask' &&
|
|
339
|
+
event.id &&
|
|
340
|
+
!answeredTools.has(event.id))
|
|
341
|
+
events.push({ type: 'approval-request', request: approvalOf(event.id, shown, toolName, e.input) });
|
|
342
|
+
// The session waits idle for the result; the step shows first, then the tool runs.
|
|
343
|
+
const toolUseId = event.id;
|
|
344
|
+
if (event.type === 'agent.custom_tool_use' && toolUseId && !answeredTools.has(toolUseId))
|
|
345
|
+
return { update: { ...at, events }, afterward: () => runTool(c, id, toolUseId, toolName, e.input, both) };
|
|
346
|
+
return { update: { ...at, events } };
|
|
347
|
+
}
|
|
348
|
+
case 'agent.tool_result':
|
|
349
|
+
case 'agent.mcp_tool_result':
|
|
350
|
+
case 'user.custom_tool_result': {
|
|
351
|
+
const toolId = String(e.tool_use_id ?? e.mcp_tool_use_id ?? e.custom_tool_use_id ?? '');
|
|
352
|
+
const output = textOf(e.content);
|
|
353
|
+
const events = [
|
|
354
|
+
{
|
|
355
|
+
type: 'tool-end',
|
|
356
|
+
...(toolId ? { id: toolId } : {}),
|
|
357
|
+
...(tools.has(toolId) ? { name: tools.get(toolId) } : {}),
|
|
358
|
+
...(e.is_error ? { isError: true } : {}),
|
|
359
|
+
...(output ? { output } : {}),
|
|
360
|
+
},
|
|
361
|
+
];
|
|
362
|
+
return { update: { ...at, events } };
|
|
363
|
+
}
|
|
364
|
+
case 'user.message':
|
|
365
|
+
// A new turn: an earlier turn's error does not explain how this one ends.
|
|
366
|
+
lastError = undefined;
|
|
367
|
+
return { update: at };
|
|
368
|
+
case 'user.tool_confirmation':
|
|
369
|
+
return {
|
|
370
|
+
update: {
|
|
371
|
+
...at,
|
|
372
|
+
events: [
|
|
373
|
+
{
|
|
374
|
+
type: 'approval-resolved',
|
|
375
|
+
id: String(e.tool_use_id),
|
|
376
|
+
decision: e.result === 'allow' ? 'approve' : 'deny',
|
|
377
|
+
},
|
|
378
|
+
],
|
|
379
|
+
},
|
|
380
|
+
};
|
|
381
|
+
case 'session.error': {
|
|
382
|
+
const error = sessionError(event);
|
|
383
|
+
if (error.terminal)
|
|
384
|
+
lastError = error;
|
|
385
|
+
return { update: { ...at, events: [{ type: 'error', message: error.message }] } };
|
|
386
|
+
}
|
|
387
|
+
case 'session.usage': {
|
|
388
|
+
const usage = (e.usage ?? {});
|
|
389
|
+
const tokens = usageOf(usage) ?? {};
|
|
390
|
+
const cost = usage?.list_cost;
|
|
391
|
+
const costUsd = cost && cost.currency === 'USD' && /^\d+$/.test(cost.amount) ? Number(cost.amount) / 100 : undefined;
|
|
392
|
+
return {
|
|
393
|
+
update: {
|
|
394
|
+
...at,
|
|
395
|
+
events: [{ type: 'usage', usage: tokens, ...(costUsd !== undefined ? { costUsd } : {}) }],
|
|
396
|
+
},
|
|
397
|
+
};
|
|
398
|
+
}
|
|
399
|
+
case 'span.model_request_end': {
|
|
400
|
+
// The session's running totals, for budgets checked as the run goes.
|
|
401
|
+
const session = await retrieve(id, both);
|
|
402
|
+
return session
|
|
403
|
+
? { update: { ...at, snapshot: snapshotOf(session, { state: 'running' }) } }
|
|
404
|
+
: { update: at };
|
|
405
|
+
}
|
|
406
|
+
case 'session.status_running':
|
|
407
|
+
case 'session.status_rescheduled':
|
|
408
|
+
return {
|
|
409
|
+
update: {
|
|
410
|
+
...at,
|
|
411
|
+
snapshot: { id, state: 'running', vendorState: event.type.slice('session.status_'.length) },
|
|
412
|
+
},
|
|
413
|
+
};
|
|
414
|
+
case 'session.status_idle': {
|
|
415
|
+
// A watch that reconnected past the turn's error reads it back from the history.
|
|
416
|
+
if (e.stop_reason?.type === 'retries_exhausted' && !lastError)
|
|
417
|
+
lastError = await turnError(id, both);
|
|
418
|
+
const stop = stopOf(e, lastError);
|
|
419
|
+
if (stop.stopReason === 'requires-action')
|
|
420
|
+
return { update: { ...at, snapshot: { id, state: 'idle', vendorState: 'idle', ...stop } } };
|
|
421
|
+
const session = await retrieve(id, both);
|
|
422
|
+
const base = session ? snapshotOf(session) : { id };
|
|
423
|
+
return {
|
|
424
|
+
update: { ...at, snapshot: { ...base, state: 'idle', vendorState: 'idle', ...stop } },
|
|
425
|
+
done: true,
|
|
426
|
+
};
|
|
427
|
+
}
|
|
428
|
+
case 'session.status_terminated': {
|
|
429
|
+
lastError ??= await turnError(id, both);
|
|
430
|
+
const session = await retrieve(id, both);
|
|
431
|
+
const failed = lastError;
|
|
432
|
+
const snapshot = {
|
|
433
|
+
...(session ? snapshotOf(session) : { id }),
|
|
434
|
+
state: failed ? 'failed' : 'completed',
|
|
435
|
+
vendorState: 'terminated',
|
|
436
|
+
...(failed ? { error: failed.message, ...(failed.failure ? { failure: failed.failure } : {}) } : {}),
|
|
437
|
+
endedAt: Date.now(),
|
|
438
|
+
};
|
|
439
|
+
return { update: { ...at, snapshot }, done: true };
|
|
440
|
+
}
|
|
441
|
+
case 'session.deleted':
|
|
442
|
+
return { update: { ...at, snapshot: { id, state: 'cancelled', vendorState: 'deleted' } }, done: true };
|
|
443
|
+
default:
|
|
444
|
+
return event.id ? { update: at } : {};
|
|
445
|
+
}
|
|
446
|
+
};
|
|
447
|
+
// A dropped connection ends the stream quietly: `managedAgent()` reads the state and reconnects.
|
|
448
|
+
const dropped = (error) => failureOfError(error)?.kind === 'unavailable';
|
|
449
|
+
/** Persisted events after `from` not seen yet; true once the session settled. */
|
|
450
|
+
async function* replay(from) {
|
|
451
|
+
const history = [];
|
|
452
|
+
for await (const event of after(id, from, both))
|
|
453
|
+
if (!event.id || !seen.has(event.id))
|
|
454
|
+
history.push(event);
|
|
455
|
+
// Custom tool calls the history already answered only show; they do not run again.
|
|
456
|
+
for (const event of history) {
|
|
457
|
+
if (event.type === 'user.custom_tool_result')
|
|
458
|
+
answeredTools.add(String(event.custom_tool_use_id));
|
|
459
|
+
// Approvals the history already settled are not asked again.
|
|
460
|
+
if (event.type === 'user.tool_confirmation')
|
|
461
|
+
answeredTools.add(String(event.tool_use_id));
|
|
462
|
+
}
|
|
463
|
+
// Turns that later history continued are over: their idle is no end for this watch.
|
|
464
|
+
const lastStart = history.findLastIndex((event) => TURN_STARTS.has(event.type));
|
|
465
|
+
for (const [index, event] of history.entries()) {
|
|
466
|
+
if (event.id)
|
|
467
|
+
seen.add(event.id);
|
|
468
|
+
const { update, done, afterward } = await translate(event);
|
|
469
|
+
const past = index < lastStart && SESSION_STOPS.has(event.type);
|
|
470
|
+
if (update)
|
|
471
|
+
yield past ? { ...update, snapshot: undefined } : update;
|
|
472
|
+
if (done && !past)
|
|
473
|
+
return true;
|
|
474
|
+
await afterward?.();
|
|
475
|
+
}
|
|
476
|
+
return false;
|
|
477
|
+
}
|
|
478
|
+
try {
|
|
479
|
+
// Stream first, then history: nothing in between is lost, and duplicates are skipped by id.
|
|
480
|
+
let stream;
|
|
481
|
+
try {
|
|
482
|
+
stream = await c.beta.sessions.events.stream(id, options.textDeltas === false ? {} : { event_deltas: ['agent.message'] }, { signal: both });
|
|
483
|
+
}
|
|
484
|
+
catch (error) {
|
|
485
|
+
if (signal.aborted || !dropped(error))
|
|
486
|
+
throw error;
|
|
487
|
+
}
|
|
488
|
+
if (yield* replay(cursor))
|
|
489
|
+
return;
|
|
490
|
+
// No stream: what is persisted so far was read; `managedAgent()` checks the state and reconnects.
|
|
491
|
+
if (!stream)
|
|
492
|
+
return;
|
|
493
|
+
const live = stream[Symbol.asyncIterator]();
|
|
494
|
+
for (;;) {
|
|
495
|
+
let next;
|
|
496
|
+
try {
|
|
497
|
+
next = await live.next();
|
|
498
|
+
}
|
|
499
|
+
catch (error) {
|
|
500
|
+
if (signal.aborted || !dropped(error))
|
|
501
|
+
throw error;
|
|
502
|
+
break;
|
|
503
|
+
}
|
|
504
|
+
if (next.done)
|
|
505
|
+
break;
|
|
506
|
+
const event = next.value;
|
|
507
|
+
if (event.id && seen.has(event.id))
|
|
508
|
+
continue;
|
|
509
|
+
if (event.id)
|
|
510
|
+
seen.add(event.id);
|
|
511
|
+
// Live previews of messages the history already holds are stale.
|
|
512
|
+
if (event.type === 'event_delta' && seen.has(String(event.event_id)))
|
|
513
|
+
continue;
|
|
514
|
+
const { update, done, afterward } = await translate(event);
|
|
515
|
+
if (update)
|
|
516
|
+
yield update;
|
|
517
|
+
if (done)
|
|
518
|
+
return;
|
|
519
|
+
await afterward?.();
|
|
520
|
+
}
|
|
521
|
+
// The stream ended or dropped: what it missed is persisted, so read it before the state check.
|
|
522
|
+
yield* replay(position);
|
|
523
|
+
}
|
|
524
|
+
catch (error) {
|
|
525
|
+
if (signal.aborted)
|
|
526
|
+
return;
|
|
527
|
+
throw error;
|
|
528
|
+
}
|
|
529
|
+
finally {
|
|
530
|
+
local.abort();
|
|
531
|
+
}
|
|
532
|
+
},
|
|
533
|
+
async send(id, text) {
|
|
534
|
+
const c = await client();
|
|
535
|
+
await c.beta.sessions.events.send(id, { events: [{ type: 'user.message', content: [{ type: 'text', text }] }] });
|
|
536
|
+
},
|
|
537
|
+
async answer(id, approvalId, decision, note) {
|
|
538
|
+
const c = await client();
|
|
539
|
+
await c.beta.sessions.events.send(id, {
|
|
540
|
+
events: [
|
|
541
|
+
{
|
|
542
|
+
type: 'user.tool_confirmation',
|
|
543
|
+
tool_use_id: approvalId,
|
|
544
|
+
result: decision === 'approve' ? 'allow' : 'deny',
|
|
545
|
+
...(decision === 'deny' && note ? { deny_message: note } : {}),
|
|
546
|
+
},
|
|
547
|
+
],
|
|
548
|
+
});
|
|
549
|
+
},
|
|
550
|
+
async interrupt(id) {
|
|
551
|
+
const c = await client();
|
|
552
|
+
await c.beta.sessions.events.send(id, { events: [{ type: 'user.interrupt' }] });
|
|
553
|
+
return { enforced: true };
|
|
554
|
+
},
|
|
555
|
+
async release(snapshot) {
|
|
556
|
+
await freeAll(await client(), snapshot.release ?? []);
|
|
557
|
+
},
|
|
558
|
+
async delete(id) {
|
|
559
|
+
const c = await client();
|
|
560
|
+
try {
|
|
561
|
+
await c.beta.sessions.delete(id);
|
|
562
|
+
}
|
|
563
|
+
catch (error) {
|
|
564
|
+
if (statusOf(error) !== 404)
|
|
565
|
+
throw error;
|
|
566
|
+
}
|
|
567
|
+
},
|
|
568
|
+
};
|
|
569
|
+
/** Run a custom tool and send its result; the result's echo on the stream closes the tool step. */
|
|
570
|
+
async function runTool(c, sessionId, toolUseId, toolName, input, signal) {
|
|
571
|
+
const handler = options.tools?.[toolName];
|
|
572
|
+
let text;
|
|
573
|
+
let isError = false;
|
|
574
|
+
try {
|
|
575
|
+
if (!handler)
|
|
576
|
+
throw new Error(`No handler for custom tool '${toolName}'.`);
|
|
577
|
+
// A handler that ignores `signal` must not keep an aborted run from stopping the session.
|
|
578
|
+
const result = await untilAbort(Promise.resolve(handler((input ?? {}), { sessionId, signal })), signal);
|
|
579
|
+
if (result === ABORTED)
|
|
580
|
+
return;
|
|
581
|
+
text = result;
|
|
582
|
+
}
|
|
583
|
+
catch (error) {
|
|
584
|
+
text = error instanceof Error ? error.message : String(error);
|
|
585
|
+
isError = true;
|
|
586
|
+
}
|
|
587
|
+
if (signal.aborted)
|
|
588
|
+
return;
|
|
589
|
+
// A result that does not arrive leaves the session waiting: let the run fail on it.
|
|
590
|
+
await c.beta.sessions.events.send(sessionId, {
|
|
591
|
+
events: [
|
|
592
|
+
{
|
|
593
|
+
type: 'user.custom_tool_result',
|
|
594
|
+
custom_tool_use_id: toolUseId,
|
|
595
|
+
content: [{ type: 'text', text }],
|
|
596
|
+
...(isError ? { is_error: true } : {}),
|
|
597
|
+
},
|
|
598
|
+
],
|
|
599
|
+
}, { signal });
|
|
600
|
+
}
|
|
601
|
+
return provider;
|
|
602
|
+
}
|
|
603
|
+
const ABORTED = Symbol('aborted');
|
|
604
|
+
/** Events that begin work in a session. */
|
|
605
|
+
const TURN_STARTS = new Set(['user.message', 'session.status_running', 'session.status_rescheduled']);
|
|
606
|
+
/** Events that report the session stopped. */
|
|
607
|
+
const SESSION_STOPS = new Set(['session.status_idle', 'session.status_terminated']);
|
|
608
|
+
/** `work`'s value, or `ABORTED` as soon as `signal` aborts. */
|
|
609
|
+
function untilAbort(work, signal) {
|
|
610
|
+
if (signal.aborted)
|
|
611
|
+
return Promise.resolve(ABORTED);
|
|
612
|
+
return new Promise((resolve, reject) => {
|
|
613
|
+
const onAbort = () => resolve(ABORTED);
|
|
614
|
+
signal.addEventListener('abort', onAbort, { once: true });
|
|
615
|
+
work.then((value) => {
|
|
616
|
+
signal.removeEventListener('abort', onAbort);
|
|
617
|
+
resolve(value);
|
|
618
|
+
}, (error) => {
|
|
619
|
+
signal.removeEventListener('abort', onAbort);
|
|
620
|
+
reject(error);
|
|
621
|
+
});
|
|
622
|
+
});
|
|
623
|
+
}
|
|
624
|
+
async function defaultClient() {
|
|
625
|
+
const sdk = (await import('@anthropic-ai/sdk'));
|
|
626
|
+
const client = new sdk.default();
|
|
627
|
+
if (!client.beta?.sessions)
|
|
628
|
+
throw new Error('anthropicManaged needs an @anthropic-ai/sdk version with Managed Agents (beta.sessions): pass `client: new Anthropic()` from it.');
|
|
629
|
+
return client;
|
|
630
|
+
}
|
|
631
|
+
/** The `agent` of `sessions.create`: the plain reference, or one with this run's overrides. */
|
|
632
|
+
async function agentFor(client, ref, request, signal) {
|
|
633
|
+
const plain = ref.version !== undefined ? { type: 'agent', id: ref.id, version: ref.version } : ref.id;
|
|
634
|
+
const servers = request.mcpServers ?? [];
|
|
635
|
+
if (request.model === undefined && request.effort === undefined && !request.system && !servers.length)
|
|
636
|
+
return plain;
|
|
637
|
+
const agent = await client.beta.agents.retrieve(ref.id, ref.version !== undefined ? { version: ref.version } : undefined, signal ? { signal } : undefined);
|
|
638
|
+
const override = { type: 'agent_with_overrides', id: agent.id, version: agent.version };
|
|
639
|
+
if (request.model !== undefined || request.effort !== undefined) {
|
|
640
|
+
// An override replaces the model object whole: keep the agent's settings for the same model.
|
|
641
|
+
const same = request.model === undefined || request.model === agent.model.id;
|
|
642
|
+
const { effort: agentEffort, ...rest } = agent.model;
|
|
643
|
+
const effort = request.effort ?? (same ? effortOf(agentEffort) : undefined);
|
|
644
|
+
override.model = { ...(same ? rest : {}), id: request.model ?? agent.model.id, ...(effort ? { effort } : {}) };
|
|
645
|
+
}
|
|
646
|
+
if (request.system)
|
|
647
|
+
override.system = agent.system ? `${agent.system}\n\n${request.system}` : request.system;
|
|
648
|
+
const known = agent.mcp_servers ?? [];
|
|
649
|
+
const added = [];
|
|
650
|
+
for (const server of servers) {
|
|
651
|
+
if (!('url' in server))
|
|
652
|
+
continue;
|
|
653
|
+
const existing = known.find((s) => s.name === server.name);
|
|
654
|
+
if (existing && existing.url !== server.url)
|
|
655
|
+
throw new Error(`MCP server '${server.name}' is already on the agent with another URL (${existing.url}).`);
|
|
656
|
+
if (!existing)
|
|
657
|
+
added.push(server);
|
|
658
|
+
}
|
|
659
|
+
if (added.length) {
|
|
660
|
+
override.mcp_servers = [
|
|
661
|
+
...known.map((s) => ({ type: 'url', name: s.name, url: s.url })),
|
|
662
|
+
...added.map((s) => ({ type: 'url', name: s.name, url: s.url })),
|
|
663
|
+
];
|
|
664
|
+
// A tools override lists every tool; MCP tools keep the platform's default policy (ask).
|
|
665
|
+
override.tools = [...(agent.tools ?? []), ...added.map((s) => ({ type: 'mcp_toolset', mcp_server_name: s.name }))];
|
|
666
|
+
}
|
|
667
|
+
return override;
|
|
668
|
+
}
|
|
669
|
+
/** MCP servers' bearer tokens, for the session's vault. Other headers cannot be vaulted. */
|
|
670
|
+
function bearers(name, servers) {
|
|
671
|
+
const out = [];
|
|
672
|
+
for (const server of servers) {
|
|
673
|
+
if (!('url' in server) || !server.headers)
|
|
674
|
+
continue;
|
|
675
|
+
const entries = Object.entries(server.headers);
|
|
676
|
+
if (!entries.length)
|
|
677
|
+
continue;
|
|
678
|
+
const [key, value] = entries[0];
|
|
679
|
+
const token = /^Bearer\s+(.+)$/i.exec(value)?.[1];
|
|
680
|
+
if (entries.length > 1 || key.toLowerCase() !== 'authorization' || !token)
|
|
681
|
+
throw new Error(`${name} passes MCP credentials only as 'Authorization: Bearer ...'; '${server.name}' has other headers.`);
|
|
682
|
+
out.push({ server: { name: server.name, url: server.url }, token });
|
|
683
|
+
}
|
|
684
|
+
return out;
|
|
685
|
+
}
|
|
686
|
+
/** Fields a running session cannot change. */
|
|
687
|
+
function refusedOnResume(name, session, request) {
|
|
688
|
+
if (request.files?.length)
|
|
689
|
+
throw new Error(`${name} mounts files only when a session starts.`);
|
|
690
|
+
const model = session.agent?.model;
|
|
691
|
+
if (request.model !== undefined && model && request.model !== model.id)
|
|
692
|
+
throw new Error(`${name} session ${session.id} runs ${model.id}; its model cannot change.`);
|
|
693
|
+
if (request.effort !== undefined && model && request.effort !== effortOf(model.effort))
|
|
694
|
+
throw new Error(`${name} session ${session.id} runs at effort '${effortOf(model.effort) ?? 'default'}'; it cannot change.`);
|
|
695
|
+
for (const server of request.mcpServers ?? []) {
|
|
696
|
+
if (!('url' in server))
|
|
697
|
+
continue;
|
|
698
|
+
if (server.headers && Object.keys(server.headers).length)
|
|
699
|
+
throw new Error(`${name} attaches MCP credentials only when a session starts ('${server.name}').`);
|
|
700
|
+
if (!session.agent?.mcp_servers?.some((s) => s.url === server.url))
|
|
701
|
+
throw new Error(`${name} session ${session.id} has no MCP server at ${server.url}; servers are set when it starts.`);
|
|
702
|
+
}
|
|
703
|
+
}
|
|
704
|
+
async function freeAll(client, refs) {
|
|
705
|
+
await Promise.allSettled(refs.map((ref) => ref.startsWith('vault:')
|
|
706
|
+
? client.beta.vaults.delete(ref.slice(6))
|
|
707
|
+
: ref.startsWith('file:')
|
|
708
|
+
? client.beta.files.delete(ref.slice(5))
|
|
709
|
+
: undefined));
|
|
710
|
+
}
|
|
711
|
+
/** `https://github.com/owner/repo[.git][#branch]`. */
|
|
712
|
+
function githubWorkspace(workspace) {
|
|
713
|
+
const match = workspace && /^(https:\/\/github\.com\/[^/\s#]+\/[^/\s#]+?)(?:\.git)?\/?(?:#(.+))?$/.exec(workspace);
|
|
714
|
+
return match ? { url: match[1], ...(match[2] ? { branch: match[2] } : {}) } : undefined;
|
|
715
|
+
}
|
|
716
|
+
function sessionError(event) {
|
|
717
|
+
const error = (event.error ?? {});
|
|
718
|
+
const kind = error.type ?? 'error';
|
|
719
|
+
const failure = kind === 'model_rate_limited_error' || kind === 'billing_error'
|
|
720
|
+
? { kind: 'quota' }
|
|
721
|
+
: kind === 'model_overloaded_error'
|
|
722
|
+
? { kind: 'unavailable' }
|
|
723
|
+
: undefined;
|
|
724
|
+
return {
|
|
725
|
+
message: error.message ? `${kind}: ${error.message}` : kind,
|
|
726
|
+
terminal: error.retry_status?.type !== 'retrying',
|
|
727
|
+
...(failure ? { failure } : {}),
|
|
728
|
+
};
|
|
729
|
+
}
|
|
730
|
+
/** A `session.status_idle` event's reason, normalized. */
|
|
731
|
+
function stopOf(event, lastError) {
|
|
732
|
+
const reason = event.stop_reason?.type;
|
|
733
|
+
const details = event.stop_details;
|
|
734
|
+
const map = {
|
|
735
|
+
end_turn: 'end-turn',
|
|
736
|
+
requires_action: 'requires-action',
|
|
737
|
+
budget_reached: 'budget',
|
|
738
|
+
retries_exhausted: 'error',
|
|
739
|
+
refusal: 'error',
|
|
740
|
+
};
|
|
741
|
+
const stopReason = reason ? (map[reason] ?? reason) : 'end-turn';
|
|
742
|
+
if (stopReason !== 'error')
|
|
743
|
+
return { stopReason };
|
|
744
|
+
const error = reason === 'refusal'
|
|
745
|
+
? `The model refused${details?.explanation ? `: ${details.explanation}` : '.'}`
|
|
746
|
+
: (lastError?.message ?? 'Retries exhausted.');
|
|
747
|
+
return { stopReason, error, ...(reason !== 'refusal' && lastError?.failure ? { failure: lastError.failure } : {}) };
|
|
748
|
+
}
|
|
749
|
+
function usageOf(usage) {
|
|
750
|
+
if (!usage)
|
|
751
|
+
return undefined;
|
|
752
|
+
const details = {};
|
|
753
|
+
const created = (usage.cache_creation?.ephemeral_1h_input_tokens ?? 0) + (usage.cache_creation?.ephemeral_5m_input_tokens ?? 0);
|
|
754
|
+
if (created)
|
|
755
|
+
details.cacheCreationInputTokens = created;
|
|
756
|
+
if (usage.active_seconds !== undefined)
|
|
757
|
+
details.activeSeconds = usage.active_seconds;
|
|
758
|
+
const out = {
|
|
759
|
+
...(usage.input_tokens !== undefined ? { inputTokens: usage.input_tokens } : {}),
|
|
760
|
+
...(usage.output_tokens !== undefined ? { outputTokens: usage.output_tokens } : {}),
|
|
761
|
+
...(usage.cache_read_input_tokens !== undefined ? { cachedInputTokens: usage.cache_read_input_tokens } : {}),
|
|
762
|
+
...(Object.keys(details).length ? { details } : {}),
|
|
763
|
+
};
|
|
764
|
+
return Object.keys(out).length ? out : undefined;
|
|
765
|
+
}
|
|
766
|
+
function approvalOf(id, shown, tool, input) {
|
|
767
|
+
const args = (input ?? {});
|
|
768
|
+
const path = typeof args.file_path === 'string' ? args.file_path : typeof args.path === 'string' ? args.path : undefined;
|
|
769
|
+
if (tool === 'bash' && typeof args.command === 'string')
|
|
770
|
+
return { id, kind: 'command', summary: args.command, detail: input };
|
|
771
|
+
if ((tool === 'write' || tool === 'edit') && shown === tool)
|
|
772
|
+
return { id, kind: 'file-change', summary: path ?? tool, detail: input };
|
|
773
|
+
return { id, kind: 'other', summary: shown, detail: input };
|
|
774
|
+
}
|
|
775
|
+
function effortOf(effort) {
|
|
776
|
+
return typeof effort === 'string' ? effort : effort?.type;
|
|
777
|
+
}
|
|
778
|
+
function textOf(content) {
|
|
779
|
+
if (!Array.isArray(content))
|
|
780
|
+
return '';
|
|
781
|
+
return content
|
|
782
|
+
.filter((block) => block?.type === 'text' && typeof block.text === 'string')
|
|
783
|
+
.map((block) => block.text)
|
|
784
|
+
.join('');
|
|
785
|
+
}
|
|
786
|
+
function statusOf(error) {
|
|
787
|
+
const status = error?.status;
|
|
788
|
+
return typeof status === 'number' ? status : undefined;
|
|
789
|
+
}
|
|
790
|
+
function formatCursor(time, id) {
|
|
791
|
+
return `${time}|${id}`;
|
|
792
|
+
}
|
|
793
|
+
function parseCursor(cursor) {
|
|
794
|
+
if (!cursor)
|
|
795
|
+
return undefined;
|
|
796
|
+
const at = cursor.lastIndexOf('|');
|
|
797
|
+
return at > 0 ? { time: cursor.slice(0, at), id: cursor.slice(at + 1) } : undefined;
|
|
798
|
+
}
|
|
799
|
+
//# sourceMappingURL=anthropic-managed.js.map
|