@deepagents/experimental 7.0.2 → 7.1.1
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 +8 -4
- package/dist/coding-agent-reminders/evaluate.d.ts.map +1 -1
- package/dist/coding-agent-reminders/index.js +2 -2
- package/dist/coding-agent-reminders/index.js.map +2 -2
- package/dist/index.js +233 -180
- package/dist/index.js.map +3 -3
- package/dist/providers/account-tokens.d.ts +45 -0
- package/dist/providers/account-tokens.d.ts.map +1 -0
- package/dist/providers/claude/accounts.d.ts +59 -0
- package/dist/providers/claude/accounts.d.ts.map +1 -0
- package/dist/providers/claude/errors.d.ts +7 -0
- package/dist/providers/claude/errors.d.ts.map +1 -0
- package/dist/providers/claude/index.d.ts +2 -0
- package/dist/providers/claude/index.d.ts.map +1 -1
- package/dist/providers/claude/index.js +540 -52
- package/dist/providers/claude/index.js.map +4 -4
- package/dist/providers/claude/local-credentials.d.ts.map +1 -1
- package/dist/providers/claude/oauth.d.ts +3 -0
- package/dist/providers/claude/oauth.d.ts.map +1 -0
- package/dist/providers/claude/provider.d.ts +4 -0
- package/dist/providers/claude/provider.d.ts.map +1 -0
- package/dist/providers/codex/accounts.d.ts +39 -0
- package/dist/providers/codex/accounts.d.ts.map +1 -0
- package/dist/providers/codex/errors.d.ts +7 -0
- package/dist/providers/codex/errors.d.ts.map +1 -0
- package/dist/providers/codex/index.d.ts +2 -0
- package/dist/providers/codex/index.d.ts.map +1 -1
- package/dist/providers/codex/index.js +472 -168
- package/dist/providers/codex/index.js.map +4 -4
- package/dist/providers/codex/local-credentials.d.ts.map +1 -1
- package/dist/providers/codex/provider.d.ts +3 -0
- package/dist/providers/codex/provider.d.ts.map +1 -0
- package/dist/providers/request-signal.d.ts +2 -0
- package/dist/providers/request-signal.d.ts.map +1 -0
- package/dist/zukhruf/control-plane/agent-control-plane.d.ts.map +1 -1
- package/dist/zukhruf/control-plane/agent-history-forker.d.ts.map +1 -1
- package/dist/zukhruf/index.js +231 -178
- package/dist/zukhruf/index.js.map +3 -3
- package/dist/zukhruf/mailbox/coordinator.d.ts.map +1 -1
- package/dist/zukhruf/mailbox/sqlite.store.d.ts.map +1 -1
- package/dist/zukhruf/mailbox/types.d.ts +4 -4
- package/dist/zukhruf/mailbox/types.d.ts.map +1 -1
- package/dist/zukhruf/plugins/conversation-scheduling/conversation-scheduler.d.ts.map +1 -1
- package/dist/zukhruf/plugins/conversation-scheduling/index.js +18 -2
- package/dist/zukhruf/plugins/conversation-scheduling/index.js.map +2 -2
- package/dist/zukhruf/plugins/http/index.js +16 -17
- package/dist/zukhruf/plugins/http/index.js.map +3 -3
- package/dist/zukhruf/plugins/http/validator.d.ts +14 -44
- package/dist/zukhruf/plugins/http/validator.d.ts.map +1 -1
- package/dist/zukhruf/plugins/schedules/http.d.ts.map +1 -1
- package/dist/zukhruf/plugins/schedules/http.js +22 -22
- package/dist/zukhruf/plugins/schedules/http.js.map +3 -3
- package/dist/zukhruf/plugins/schedules/index.d.ts.map +1 -1
- package/dist/zukhruf/plugins/schedules/index.js +173 -51
- package/dist/zukhruf/plugins/schedules/index.js.map +3 -3
- package/dist/zukhruf/plugins/schedules/scheduled-tasks.d.ts +3 -0
- package/dist/zukhruf/plugins/schedules/scheduled-tasks.d.ts.map +1 -1
- package/dist/zukhruf/plugins/uploads/http.js +17 -20
- package/dist/zukhruf/plugins/uploads/http.js.map +3 -3
- package/dist/zukhruf/plugins/uploads/index.d.ts.map +1 -1
- package/dist/zukhruf/plugins/uploads/index.js +1 -3
- package/dist/zukhruf/plugins/uploads/index.js.map +2 -2
- package/dist/zukhruf/queue/pg-boss-notifications.d.ts.map +1 -1
- package/dist/zukhruf/queue/pg-boss.turn-queue.d.ts.map +1 -1
- package/dist/zukhruf/render-turn.d.ts.map +1 -1
- package/dist/zukhruf/runtime/agent-runtime.d.ts +3 -0
- package/dist/zukhruf/runtime/agent-runtime.d.ts.map +1 -1
- package/dist/zukhruf/runtime/agent-turn-executor.d.ts.map +1 -1
- package/dist/zukhruf/runtime/compaction.d.ts +4 -4
- package/dist/zukhruf/runtime/compaction.d.ts.map +1 -1
- package/dist/zukhruf/runtime/conversation-status/projector.d.ts.map +1 -1
- package/dist/zukhruf/runtime/plugin/plugin-bindings.d.ts.map +1 -1
- package/dist/zukhruf/runtime/plugin/plugin-manager.d.ts.map +1 -1
- package/dist/zukhruf/tool.d.ts +1 -1
- package/dist/zukhruf/tool.d.ts.map +1 -1
- package/package.json +10 -10
|
@@ -1,27 +1,22 @@
|
|
|
1
|
-
// packages/experimental/src/providers/
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
// packages/experimental/src/providers/language-model-provider.ts
|
|
6
|
-
import { customProvider, wrapProvider } from "ai";
|
|
7
|
-
function createLanguageModelProvider(languageModel, middleware) {
|
|
8
|
-
const provider = wrapProvider({
|
|
9
|
-
// The SDK rejects unsupported modalities; never expose the backing
|
|
10
|
-
// provider's embedding or image endpoints through a subscription transport.
|
|
11
|
-
provider: { ...customProvider({}), languageModel },
|
|
12
|
-
languageModelMiddleware: middleware
|
|
13
|
-
});
|
|
14
|
-
return Object.assign(provider.languageModel, provider);
|
|
1
|
+
// packages/experimental/src/providers/request-signal.ts
|
|
2
|
+
function requestSignal(...[input, init]) {
|
|
3
|
+
return init?.signal ?? (input instanceof Request ? input.signal : void 0);
|
|
15
4
|
}
|
|
16
5
|
|
|
17
6
|
// packages/experimental/src/providers/claude/local-credentials.ts
|
|
7
|
+
import { Mutex, SqliteStore } from "@zukhruf/mutex";
|
|
18
8
|
import { writeFile as atomicWriteFile } from "atomically";
|
|
19
9
|
import { createHash } from "node:crypto";
|
|
20
10
|
import { readFile, realpath } from "node:fs/promises";
|
|
21
11
|
import { homedir, userInfo } from "node:os";
|
|
22
12
|
import { join } from "node:path";
|
|
23
|
-
import { lock } from "proper-lockfile";
|
|
24
13
|
import { z } from "zod";
|
|
14
|
+
|
|
15
|
+
// packages/experimental/src/providers/claude/oauth.ts
|
|
16
|
+
var CLAUDE_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
|
|
17
|
+
var CLAUDE_TOKEN_URL = "https://platform.claude.com/v1/oauth/token";
|
|
18
|
+
|
|
19
|
+
// packages/experimental/src/providers/claude/local-credentials.ts
|
|
25
20
|
var nativeLogin = z.looseObject({
|
|
26
21
|
claudeAiOauth: z.looseObject({
|
|
27
22
|
accessToken: z.string().min(1),
|
|
@@ -49,11 +44,8 @@ async function getLocalClaudeAuth(signal) {
|
|
|
49
44
|
const initial = await snapshot(home, directory);
|
|
50
45
|
if (initial.value.claudeAiOauth.expiresAt > Date.now() + 6e4)
|
|
51
46
|
return initial.value.claudeAiOauth.accessToken;
|
|
52
|
-
const
|
|
53
|
-
|
|
54
|
-
retries: { retries: 20, minTimeout: 50, maxTimeout: 1e3 }
|
|
55
|
-
});
|
|
56
|
-
try {
|
|
47
|
+
const mutex = new Mutex(new SqliteStore(join(home, ".deepagents-locks")));
|
|
48
|
+
return mutex.acquire("claude", async () => {
|
|
57
49
|
for (let attempt = 0; attempt < 3; attempt++) {
|
|
58
50
|
signal?.throwIfAborted();
|
|
59
51
|
const current = await snapshot(home, directory);
|
|
@@ -61,23 +53,20 @@ async function getLocalClaudeAuth(signal) {
|
|
|
61
53
|
if (tokens.expiresAt > Date.now() + 6e4) return tokens.accessToken;
|
|
62
54
|
let fresh;
|
|
63
55
|
try {
|
|
64
|
-
const response = await globalThis.fetch(
|
|
65
|
-
"
|
|
66
|
-
{
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
71
|
-
|
|
72
|
-
|
|
73
|
-
|
|
74
|
-
|
|
75
|
-
signal:
|
|
76
|
-
|
|
77
|
-
|
|
78
|
-
])
|
|
79
|
-
}
|
|
80
|
-
);
|
|
56
|
+
const response = await globalThis.fetch(CLAUDE_TOKEN_URL, {
|
|
57
|
+
method: "POST",
|
|
58
|
+
headers: { "content-type": "application/json" },
|
|
59
|
+
body: JSON.stringify({
|
|
60
|
+
grant_type: "refresh_token",
|
|
61
|
+
refresh_token: tokens.refreshToken,
|
|
62
|
+
client_id: CLAUDE_CLIENT_ID,
|
|
63
|
+
scope: tokens.scopes.join(" ")
|
|
64
|
+
}),
|
|
65
|
+
signal: AbortSignal.any([
|
|
66
|
+
AbortSignal.timeout(3e4),
|
|
67
|
+
...signal ? [signal] : []
|
|
68
|
+
])
|
|
69
|
+
});
|
|
81
70
|
if (!response.ok) {
|
|
82
71
|
await response.body?.cancel();
|
|
83
72
|
throw new Error("Token refresh rejected");
|
|
@@ -108,9 +97,7 @@ async function getLocalClaudeAuth(signal) {
|
|
|
108
97
|
throw new Error(
|
|
109
98
|
"The local Claude login changed repeatedly during refresh. Retry the request."
|
|
110
99
|
);
|
|
111
|
-
}
|
|
112
|
-
await release();
|
|
113
|
-
}
|
|
100
|
+
});
|
|
114
101
|
}
|
|
115
102
|
async function snapshot(home, directory) {
|
|
116
103
|
const store = await credentialStore(home, directory);
|
|
@@ -145,25 +132,34 @@ async function credentialStore(home, directory) {
|
|
|
145
132
|
};
|
|
146
133
|
}
|
|
147
134
|
|
|
148
|
-
// packages/experimental/src/providers/claude/
|
|
149
|
-
|
|
135
|
+
// packages/experimental/src/providers/claude/provider.ts
|
|
136
|
+
import { createAnthropic } from "@ai-sdk/anthropic";
|
|
137
|
+
import { defaultSettingsMiddleware } from "ai";
|
|
138
|
+
|
|
139
|
+
// packages/experimental/src/providers/language-model-provider.ts
|
|
140
|
+
import { customProvider, wrapProvider } from "ai";
|
|
141
|
+
function createLanguageModelProvider(languageModel, middleware) {
|
|
142
|
+
const provider = wrapProvider({
|
|
143
|
+
// The SDK rejects unsupported modalities; never expose the backing
|
|
144
|
+
// provider's embedding or image endpoints through a subscription transport.
|
|
145
|
+
provider: { ...customProvider({}), languageModel },
|
|
146
|
+
languageModelMiddleware: middleware
|
|
147
|
+
});
|
|
148
|
+
return Object.assign(provider.languageModel, provider);
|
|
149
|
+
}
|
|
150
|
+
|
|
151
|
+
// packages/experimental/src/providers/claude/provider.ts
|
|
152
|
+
function claudeProvider(fetch) {
|
|
150
153
|
const provider = createAnthropic({
|
|
151
154
|
name: "claude.messages",
|
|
152
155
|
baseURL: "https://api.anthropic.com/v1",
|
|
153
|
-
authToken: "injected-by-
|
|
156
|
+
authToken: "injected-by-claude-subscription-transport",
|
|
154
157
|
// Native OAuth requires this private client identity. Verified with the
|
|
155
158
|
// Messages endpoint; keep compatibility details confined to this adapter.
|
|
156
159
|
headers: {
|
|
157
160
|
"anthropic-beta": "oauth-2025-04-20"
|
|
158
161
|
},
|
|
159
|
-
fetch
|
|
160
|
-
const signal = init?.signal ?? (input instanceof Request ? input.signal : void 0);
|
|
161
|
-
const token = await getLocalClaudeAuth(signal);
|
|
162
|
-
const headers = new Headers(init?.headers);
|
|
163
|
-
headers.set("authorization", `Bearer ${token}`);
|
|
164
|
-
headers.delete("x-api-key");
|
|
165
|
-
return globalThis.fetch(input, { ...init, headers });
|
|
166
|
-
}
|
|
162
|
+
fetch
|
|
167
163
|
});
|
|
168
164
|
return createLanguageModelProvider(provider.languageModel, [
|
|
169
165
|
{
|
|
@@ -188,9 +184,501 @@ function createClaude() {
|
|
|
188
184
|
})
|
|
189
185
|
]);
|
|
190
186
|
}
|
|
187
|
+
function withBearer(init, token) {
|
|
188
|
+
const headers = new Headers(init?.headers);
|
|
189
|
+
headers.set("authorization", `Bearer ${token}`);
|
|
190
|
+
headers.delete("x-api-key");
|
|
191
|
+
return { ...init, headers };
|
|
192
|
+
}
|
|
193
|
+
|
|
194
|
+
// packages/experimental/src/providers/claude/accounts.ts
|
|
195
|
+
import { createHash as createHash2, randomBytes, randomUUID } from "node:crypto";
|
|
196
|
+
import { z as z2 } from "zod";
|
|
197
|
+
|
|
198
|
+
// packages/experimental/src/providers/account-tokens.ts
|
|
199
|
+
import { MemoryStore, Mutex as Mutex2 } from "@zukhruf/mutex";
|
|
200
|
+
function createTokenVault(store, parse) {
|
|
201
|
+
const revisions = /* @__PURE__ */ new Map();
|
|
202
|
+
const serialized = new Mutex2(new MemoryStore());
|
|
203
|
+
const revision = (owner) => revisions.get(owner) ?? 0;
|
|
204
|
+
return {
|
|
205
|
+
snapshot: (owner) => serialized.acquire(owner, async () => ({
|
|
206
|
+
tokens: parse(await store.get(owner)),
|
|
207
|
+
revision: revision(owner)
|
|
208
|
+
})),
|
|
209
|
+
commit: (owner, tokens, expectedRevision) => serialized.acquire(owner, async () => {
|
|
210
|
+
if (revision(owner) !== expectedRevision) return false;
|
|
211
|
+
await store.set(owner, tokens);
|
|
212
|
+
revisions.set(owner, revision(owner) + 1);
|
|
213
|
+
return true;
|
|
214
|
+
}),
|
|
215
|
+
clear: (owner, expectedRevision) => serialized.acquire(owner, async () => {
|
|
216
|
+
if (expectedRevision !== void 0 && revision(owner) !== expectedRevision) {
|
|
217
|
+
return false;
|
|
218
|
+
}
|
|
219
|
+
await store.delete(owner);
|
|
220
|
+
revisions.set(owner, revision(owner) + 1);
|
|
221
|
+
return true;
|
|
222
|
+
})
|
|
223
|
+
};
|
|
224
|
+
}
|
|
225
|
+
function createTokenResolver(options) {
|
|
226
|
+
const exclusive = new Mutex2(new MemoryStore());
|
|
227
|
+
async function resolve(owner, rejected, signal) {
|
|
228
|
+
for (let attempt = 0; attempt < 3; attempt++) {
|
|
229
|
+
signal?.throwIfAborted();
|
|
230
|
+
const { tokens, revision } = await options.vault.snapshot(owner);
|
|
231
|
+
if (!tokens) throw options.notConnected();
|
|
232
|
+
if (tokens.accessToken !== rejected && options.isFresh(tokens)) {
|
|
233
|
+
return tokens;
|
|
234
|
+
}
|
|
235
|
+
const result = await options.refresh(tokens);
|
|
236
|
+
if (result.status === "revoked") {
|
|
237
|
+
if (!await options.vault.clear(owner, revision)) continue;
|
|
238
|
+
options.onRevoked(owner);
|
|
239
|
+
throw options.revoked();
|
|
240
|
+
}
|
|
241
|
+
if (await options.vault.commit(owner, result.tokens, revision)) {
|
|
242
|
+
return result.tokens;
|
|
243
|
+
}
|
|
244
|
+
}
|
|
245
|
+
throw options.conflicted();
|
|
246
|
+
}
|
|
247
|
+
return {
|
|
248
|
+
fresh: (owner, signal) => exclusive.acquire(owner, () => resolve(owner, void 0, signal)),
|
|
249
|
+
/** Replaces an access token the server rejected, refreshing at most once. */
|
|
250
|
+
replace: (owner, rejected, signal) => exclusive.acquire(owner, () => resolve(owner, rejected, signal))
|
|
251
|
+
};
|
|
252
|
+
}
|
|
253
|
+
async function retryUnauthorized(credential, send, replace, rejectedAgain) {
|
|
254
|
+
const response = await send(credential);
|
|
255
|
+
if (response.status !== 401) return response;
|
|
256
|
+
await response.body?.cancel();
|
|
257
|
+
const retry = await send(await replace(credential));
|
|
258
|
+
if (retry.status !== 401) return retry;
|
|
259
|
+
await retry.body?.cancel();
|
|
260
|
+
throw rejectedAgain();
|
|
261
|
+
}
|
|
262
|
+
|
|
263
|
+
// packages/experimental/src/providers/claude/errors.ts
|
|
264
|
+
var ClaudeAuthError = class extends Error {
|
|
265
|
+
code;
|
|
266
|
+
constructor(code, message) {
|
|
267
|
+
super(message);
|
|
268
|
+
this.name = "ClaudeAuthError";
|
|
269
|
+
this.code = code;
|
|
270
|
+
}
|
|
271
|
+
};
|
|
272
|
+
|
|
273
|
+
// packages/experimental/src/providers/claude/accounts.ts
|
|
274
|
+
var AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
|
|
275
|
+
var CALLBACK_URL = "https://platform.claude.com/oauth/code/callback";
|
|
276
|
+
var PROFILE_URL = "https://api.anthropic.com/api/oauth/profile";
|
|
277
|
+
var MODELS_URL = "https://api.anthropic.com/v1/models";
|
|
278
|
+
var SCOPES = ["user:profile", "user:inference"];
|
|
279
|
+
var SIGN_IN_TIMEOUT_MS = 10 * 60 * 1e3;
|
|
280
|
+
var REQUEST_TIMEOUT_MS = 3e4;
|
|
281
|
+
var PROFILE_TIMEOUT_MS = 1e4;
|
|
282
|
+
var EXPIRY_MARGIN_MS = 6e4;
|
|
283
|
+
var claudeUser = z2.object({
|
|
284
|
+
email: z2.string(),
|
|
285
|
+
name: z2.string().optional()
|
|
286
|
+
});
|
|
287
|
+
var claudeTokens = z2.object({
|
|
288
|
+
accessToken: z2.string().min(1),
|
|
289
|
+
refreshToken: z2.string().min(1),
|
|
290
|
+
expiresAt: z2.number(),
|
|
291
|
+
user: claudeUser.optional()
|
|
292
|
+
});
|
|
293
|
+
var tokenResponse2 = z2.object({
|
|
294
|
+
access_token: z2.string().min(1),
|
|
295
|
+
refresh_token: z2.string().min(1).optional(),
|
|
296
|
+
expires_in: z2.number().positive(),
|
|
297
|
+
account: z2.object({ email_address: z2.string().optional() }).optional()
|
|
298
|
+
});
|
|
299
|
+
var profileResponse = z2.object({
|
|
300
|
+
account: z2.object({
|
|
301
|
+
email: z2.string(),
|
|
302
|
+
display_name: z2.string().optional()
|
|
303
|
+
})
|
|
304
|
+
});
|
|
305
|
+
var modelsPage = z2.object({
|
|
306
|
+
data: z2.array(z2.object({ id: z2.string() })),
|
|
307
|
+
has_more: z2.boolean(),
|
|
308
|
+
last_id: z2.string().nullable()
|
|
309
|
+
});
|
|
310
|
+
function createClaudeAccounts(options) {
|
|
311
|
+
const vault = createTokenVault(
|
|
312
|
+
options.store,
|
|
313
|
+
(value) => claudeTokens.safeParse(value).data
|
|
314
|
+
);
|
|
315
|
+
const signIns = /* @__PURE__ */ new Map();
|
|
316
|
+
const tokens = createTokenResolver({
|
|
317
|
+
vault,
|
|
318
|
+
isFresh: (current) => current.expiresAt > Date.now() + EXPIRY_MARGIN_MS,
|
|
319
|
+
refresh: refreshTokens,
|
|
320
|
+
notConnected: () => new ClaudeAuthError(
|
|
321
|
+
"not-connected",
|
|
322
|
+
"No Claude account is connected. Connect one before using this model."
|
|
323
|
+
),
|
|
324
|
+
revoked: () => new ClaudeAuthError(
|
|
325
|
+
"refresh-token-invalid",
|
|
326
|
+
"The Claude connection expired or was revoked. Connect the account again."
|
|
327
|
+
),
|
|
328
|
+
conflicted: () => new ClaudeAuthError(
|
|
329
|
+
"refresh-failed",
|
|
330
|
+
"The Claude connection changed repeatedly during refresh. Retry the request."
|
|
331
|
+
),
|
|
332
|
+
onRevoked: (owner) => void publish(owner)
|
|
333
|
+
});
|
|
334
|
+
function authorizedFetch(owner) {
|
|
335
|
+
return async (input, init) => {
|
|
336
|
+
const signal = requestSignal(input, init);
|
|
337
|
+
const current = await tokens.fresh(owner, signal);
|
|
338
|
+
return retryUnauthorized(
|
|
339
|
+
current.accessToken,
|
|
340
|
+
(token) => globalThis.fetch(input, withBearer(init, token)),
|
|
341
|
+
async (rejected) => (await tokens.replace(owner, rejected, signal)).accessToken,
|
|
342
|
+
() => new ClaudeAuthError(
|
|
343
|
+
"access-token-invalid",
|
|
344
|
+
"Anthropic rejected the Claude connection. Connect the account again."
|
|
345
|
+
)
|
|
346
|
+
);
|
|
347
|
+
};
|
|
348
|
+
}
|
|
349
|
+
async function state(owner) {
|
|
350
|
+
const signIn = signIns.get(owner);
|
|
351
|
+
if (signIn) {
|
|
352
|
+
if (signIn.expiresAt > Date.now()) return pending(signIn);
|
|
353
|
+
cancel(owner);
|
|
354
|
+
}
|
|
355
|
+
try {
|
|
356
|
+
const snapshot2 = await vault.snapshot(owner);
|
|
357
|
+
if (!snapshot2.tokens) return { status: "unauthenticated" };
|
|
358
|
+
if (snapshot2.tokens.user) {
|
|
359
|
+
return { status: "connected", user: snapshot2.tokens.user };
|
|
360
|
+
}
|
|
361
|
+
const user = await fetchProfile(snapshot2.tokens.accessToken);
|
|
362
|
+
if (!user) return { status: "connected", user: null };
|
|
363
|
+
if (await vault.commit(
|
|
364
|
+
owner,
|
|
365
|
+
{ ...snapshot2.tokens, user },
|
|
366
|
+
snapshot2.revision
|
|
367
|
+
)) {
|
|
368
|
+
return { status: "connected", user };
|
|
369
|
+
}
|
|
370
|
+
const latest = (await vault.snapshot(owner)).tokens;
|
|
371
|
+
return latest ? { status: "connected", user: latest.user ?? null } : { status: "unauthenticated" };
|
|
372
|
+
} catch (error) {
|
|
373
|
+
return {
|
|
374
|
+
status: "error",
|
|
375
|
+
message: messageOf(error, "Reading the Claude connection failed.")
|
|
376
|
+
};
|
|
377
|
+
}
|
|
378
|
+
}
|
|
379
|
+
function emit(owner, current) {
|
|
380
|
+
options.onChange?.(owner, current);
|
|
381
|
+
return current;
|
|
382
|
+
}
|
|
383
|
+
async function publish(owner) {
|
|
384
|
+
return emit(owner, await state(owner));
|
|
385
|
+
}
|
|
386
|
+
function cancel(owner) {
|
|
387
|
+
const signIn = signIns.get(owner);
|
|
388
|
+
if (!signIn) return;
|
|
389
|
+
signIns.delete(owner);
|
|
390
|
+
signIn.abort.abort();
|
|
391
|
+
}
|
|
392
|
+
async function keepPending(owner, signIn, message) {
|
|
393
|
+
if (signIns.get(owner) !== signIn) return publish(owner);
|
|
394
|
+
signIn.message = message;
|
|
395
|
+
return emit(owner, pending(signIn));
|
|
396
|
+
}
|
|
397
|
+
async function fail(owner, signIn, message) {
|
|
398
|
+
if (signIns.get(owner) !== signIn) return publish(owner);
|
|
399
|
+
cancel(owner);
|
|
400
|
+
return emit(owner, { status: "error", message });
|
|
401
|
+
}
|
|
402
|
+
async function connect(owner) {
|
|
403
|
+
const existing = await state(owner);
|
|
404
|
+
if (existing.status !== "unauthenticated") return existing;
|
|
405
|
+
const { revision } = await vault.snapshot(owner);
|
|
406
|
+
const verifier = randomBytes(64).toString("base64url");
|
|
407
|
+
const oauthState = randomUUID().replaceAll("-", "");
|
|
408
|
+
const url = new URL(AUTHORIZE_URL);
|
|
409
|
+
url.searchParams.set("code", "true");
|
|
410
|
+
url.searchParams.set("client_id", CLAUDE_CLIENT_ID);
|
|
411
|
+
url.searchParams.set("response_type", "code");
|
|
412
|
+
url.searchParams.set("redirect_uri", CALLBACK_URL);
|
|
413
|
+
url.searchParams.set("scope", SCOPES.join(" "));
|
|
414
|
+
url.searchParams.set(
|
|
415
|
+
"code_challenge",
|
|
416
|
+
createHash2("sha256").update(verifier).digest("base64url")
|
|
417
|
+
);
|
|
418
|
+
url.searchParams.set("code_challenge_method", "S256");
|
|
419
|
+
url.searchParams.set("state", oauthState);
|
|
420
|
+
cancel(owner);
|
|
421
|
+
signIns.set(owner, {
|
|
422
|
+
authorizationUrl: url.href,
|
|
423
|
+
verifier,
|
|
424
|
+
state: oauthState,
|
|
425
|
+
expiresAt: Date.now() + SIGN_IN_TIMEOUT_MS,
|
|
426
|
+
revision,
|
|
427
|
+
abort: new AbortController()
|
|
428
|
+
});
|
|
429
|
+
return publish(owner);
|
|
430
|
+
}
|
|
431
|
+
async function complete(owner, input) {
|
|
432
|
+
const signIn = signIns.get(owner);
|
|
433
|
+
if (!signIn || signIn.expiresAt <= Date.now()) {
|
|
434
|
+
cancel(owner);
|
|
435
|
+
return emit(owner, {
|
|
436
|
+
status: "error",
|
|
437
|
+
message: "Claude sign-in expired. Start the connection again."
|
|
438
|
+
});
|
|
439
|
+
}
|
|
440
|
+
const callback = parseCallback(input);
|
|
441
|
+
if (!callback || callback.state !== signIn.state) {
|
|
442
|
+
return keepPending(
|
|
443
|
+
owner,
|
|
444
|
+
signIn,
|
|
445
|
+
"That authorization code is invalid or belongs to another sign-in attempt."
|
|
446
|
+
);
|
|
447
|
+
}
|
|
448
|
+
signIn.message = void 0;
|
|
449
|
+
let response;
|
|
450
|
+
try {
|
|
451
|
+
response = await globalThis.fetch(CLAUDE_TOKEN_URL, {
|
|
452
|
+
method: "POST",
|
|
453
|
+
headers: {
|
|
454
|
+
"content-type": "application/json",
|
|
455
|
+
accept: "application/json"
|
|
456
|
+
},
|
|
457
|
+
body: JSON.stringify({
|
|
458
|
+
code: callback.code,
|
|
459
|
+
state: callback.state,
|
|
460
|
+
grant_type: "authorization_code",
|
|
461
|
+
client_id: CLAUDE_CLIENT_ID,
|
|
462
|
+
redirect_uri: CALLBACK_URL,
|
|
463
|
+
code_verifier: signIn.verifier
|
|
464
|
+
}),
|
|
465
|
+
signal: AbortSignal.any([
|
|
466
|
+
signIn.abort.signal,
|
|
467
|
+
AbortSignal.timeout(REQUEST_TIMEOUT_MS)
|
|
468
|
+
])
|
|
469
|
+
});
|
|
470
|
+
} catch {
|
|
471
|
+
return keepPending(
|
|
472
|
+
owner,
|
|
473
|
+
signIn,
|
|
474
|
+
"Could not reach Anthropic to finish sign-in. Try again."
|
|
475
|
+
);
|
|
476
|
+
}
|
|
477
|
+
if (!response.ok) {
|
|
478
|
+
await response.body?.cancel();
|
|
479
|
+
const message = `Anthropic rejected the authorization code (${response.status}).`;
|
|
480
|
+
return response.status === 429 || response.status >= 500 ? keepPending(owner, signIn, `${message} Try again.`) : fail(owner, signIn, message);
|
|
481
|
+
}
|
|
482
|
+
const parsed = tokenResponse2.safeParse(
|
|
483
|
+
await response.json().catch(() => void 0)
|
|
484
|
+
);
|
|
485
|
+
if (!parsed.data?.refresh_token) {
|
|
486
|
+
return fail(
|
|
487
|
+
owner,
|
|
488
|
+
signIn,
|
|
489
|
+
"Anthropic returned an invalid sign-in response."
|
|
490
|
+
);
|
|
491
|
+
}
|
|
492
|
+
const email = parsed.data.account?.email_address;
|
|
493
|
+
try {
|
|
494
|
+
await vault.commit(
|
|
495
|
+
owner,
|
|
496
|
+
{
|
|
497
|
+
accessToken: parsed.data.access_token,
|
|
498
|
+
refreshToken: parsed.data.refresh_token,
|
|
499
|
+
expiresAt: Date.now() + parsed.data.expires_in * 1e3,
|
|
500
|
+
...email && { user: { email } }
|
|
501
|
+
},
|
|
502
|
+
signIn.revision
|
|
503
|
+
);
|
|
504
|
+
} catch (error) {
|
|
505
|
+
return fail(
|
|
506
|
+
owner,
|
|
507
|
+
signIn,
|
|
508
|
+
messageOf(error, "Saving the Claude connection failed.")
|
|
509
|
+
);
|
|
510
|
+
}
|
|
511
|
+
if (signIns.get(owner) === signIn) signIns.delete(owner);
|
|
512
|
+
return publish(owner);
|
|
513
|
+
}
|
|
514
|
+
async function disconnect(owner) {
|
|
515
|
+
cancel(owner);
|
|
516
|
+
await vault.clear(owner);
|
|
517
|
+
return publish(owner);
|
|
518
|
+
}
|
|
519
|
+
async function listModels(owner, signal) {
|
|
520
|
+
const fetch = authorizedFetch(owner);
|
|
521
|
+
const ids = [];
|
|
522
|
+
let after;
|
|
523
|
+
do {
|
|
524
|
+
const url = new URL(MODELS_URL);
|
|
525
|
+
url.searchParams.set("limit", "1000");
|
|
526
|
+
if (after) url.searchParams.set("after_id", after);
|
|
527
|
+
const response = await fetch(url, {
|
|
528
|
+
headers: {
|
|
529
|
+
"anthropic-version": "2023-06-01",
|
|
530
|
+
"anthropic-beta": "oauth-2025-04-20"
|
|
531
|
+
},
|
|
532
|
+
signal
|
|
533
|
+
});
|
|
534
|
+
if (!response.ok) {
|
|
535
|
+
await response.body?.cancel();
|
|
536
|
+
throw new ClaudeAuthError(
|
|
537
|
+
"models-request-failed",
|
|
538
|
+
`Listing Claude models failed (${response.status}).`
|
|
539
|
+
);
|
|
540
|
+
}
|
|
541
|
+
const page = modelsPage.safeParse(await response.json());
|
|
542
|
+
if (!page.success) {
|
|
543
|
+
throw new ClaudeAuthError(
|
|
544
|
+
"models-request-failed",
|
|
545
|
+
"Anthropic returned an invalid model list."
|
|
546
|
+
);
|
|
547
|
+
}
|
|
548
|
+
ids.push(...page.data.data.map((model) => model.id));
|
|
549
|
+
after = page.data.has_more ? page.data.last_id ?? void 0 : void 0;
|
|
550
|
+
} while (after);
|
|
551
|
+
return ids;
|
|
552
|
+
}
|
|
553
|
+
return {
|
|
554
|
+
/** AI SDK models authenticated as this owner's Claude account. */
|
|
555
|
+
provider: (owner) => claudeProvider(authorizedFetch(owner)),
|
|
556
|
+
/** Model ids this owner's account can run, from Anthropic's model list. */
|
|
557
|
+
listModels,
|
|
558
|
+
state,
|
|
559
|
+
/** Starts PKCE sign-in; open the returned `authorizationUrl` for the user. */
|
|
560
|
+
connect,
|
|
561
|
+
/** Finishes sign-in with the code, `code#state`, or callback URL Claude shows. */
|
|
562
|
+
complete,
|
|
563
|
+
/** Abandons an in-flight sign-in, for example when the owner signs out. */
|
|
564
|
+
cancel,
|
|
565
|
+
disconnect
|
|
566
|
+
};
|
|
567
|
+
}
|
|
568
|
+
function pending(signIn) {
|
|
569
|
+
return {
|
|
570
|
+
status: "pending",
|
|
571
|
+
authorizationUrl: signIn.authorizationUrl,
|
|
572
|
+
expiresAt: new Date(signIn.expiresAt).toISOString(),
|
|
573
|
+
...signIn.message && { message: signIn.message }
|
|
574
|
+
};
|
|
575
|
+
}
|
|
576
|
+
async function refreshTokens(current) {
|
|
577
|
+
let response;
|
|
578
|
+
try {
|
|
579
|
+
response = await globalThis.fetch(CLAUDE_TOKEN_URL, {
|
|
580
|
+
method: "POST",
|
|
581
|
+
headers: {
|
|
582
|
+
"content-type": "application/json",
|
|
583
|
+
accept: "application/json"
|
|
584
|
+
},
|
|
585
|
+
body: JSON.stringify({
|
|
586
|
+
grant_type: "refresh_token",
|
|
587
|
+
refresh_token: current.refreshToken,
|
|
588
|
+
client_id: CLAUDE_CLIENT_ID
|
|
589
|
+
}),
|
|
590
|
+
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
|
|
591
|
+
});
|
|
592
|
+
} catch {
|
|
593
|
+
throw new ClaudeAuthError(
|
|
594
|
+
"refresh-failed",
|
|
595
|
+
"Could not reach Anthropic to refresh the Claude connection. Retry the request."
|
|
596
|
+
);
|
|
597
|
+
}
|
|
598
|
+
if (response.status === 400 || response.status === 401) {
|
|
599
|
+
await response.body?.cancel();
|
|
600
|
+
return { status: "revoked" };
|
|
601
|
+
}
|
|
602
|
+
if (!response.ok) {
|
|
603
|
+
await response.body?.cancel();
|
|
604
|
+
throw new ClaudeAuthError(
|
|
605
|
+
"refresh-failed",
|
|
606
|
+
`Anthropic could not refresh the Claude connection (${response.status}). Retry the request.`
|
|
607
|
+
);
|
|
608
|
+
}
|
|
609
|
+
const parsed = tokenResponse2.safeParse(
|
|
610
|
+
await response.json().catch(() => void 0)
|
|
611
|
+
);
|
|
612
|
+
if (!parsed.success) {
|
|
613
|
+
throw new ClaudeAuthError(
|
|
614
|
+
"invalid-token-response",
|
|
615
|
+
"Anthropic returned an invalid token refresh response."
|
|
616
|
+
);
|
|
617
|
+
}
|
|
618
|
+
return {
|
|
619
|
+
status: "refreshed",
|
|
620
|
+
tokens: {
|
|
621
|
+
...current,
|
|
622
|
+
accessToken: parsed.data.access_token,
|
|
623
|
+
refreshToken: parsed.data.refresh_token ?? current.refreshToken,
|
|
624
|
+
expiresAt: Date.now() + parsed.data.expires_in * 1e3
|
|
625
|
+
}
|
|
626
|
+
};
|
|
627
|
+
}
|
|
628
|
+
async function fetchProfile(accessToken) {
|
|
629
|
+
try {
|
|
630
|
+
const response = await globalThis.fetch(PROFILE_URL, {
|
|
631
|
+
headers: {
|
|
632
|
+
authorization: `Bearer ${accessToken}`,
|
|
633
|
+
"cache-control": "no-cache"
|
|
634
|
+
},
|
|
635
|
+
signal: AbortSignal.timeout(PROFILE_TIMEOUT_MS)
|
|
636
|
+
});
|
|
637
|
+
if (!response.ok) {
|
|
638
|
+
await response.body?.cancel();
|
|
639
|
+
return void 0;
|
|
640
|
+
}
|
|
641
|
+
const profile = profileResponse.safeParse(await response.json());
|
|
642
|
+
if (!profile.success) return void 0;
|
|
643
|
+
const { email, display_name: name } = profile.data.account;
|
|
644
|
+
return name ? { email, name } : { email };
|
|
645
|
+
} catch {
|
|
646
|
+
return void 0;
|
|
647
|
+
}
|
|
648
|
+
}
|
|
649
|
+
function parseCallback(input) {
|
|
650
|
+
const trimmed = input.trim();
|
|
651
|
+
if (URL.canParse(trimmed)) {
|
|
652
|
+
const url = new URL(trimmed);
|
|
653
|
+
const code2 = url.searchParams.get("code");
|
|
654
|
+
const state2 = url.searchParams.get("state");
|
|
655
|
+
if (code2 && state2) return { code: code2, state: state2 };
|
|
656
|
+
}
|
|
657
|
+
const [code, state, extra] = trimmed.split("#");
|
|
658
|
+
if (code && state && extra === void 0) return { code, state };
|
|
659
|
+
const query = new URLSearchParams(trimmed);
|
|
660
|
+
const queryCode = query.get("code");
|
|
661
|
+
const queryState = query.get("state");
|
|
662
|
+
return queryCode && queryState ? { code: queryCode, state: queryState } : void 0;
|
|
663
|
+
}
|
|
664
|
+
function messageOf(error, fallback) {
|
|
665
|
+
return error instanceof Error ? error.message : fallback;
|
|
666
|
+
}
|
|
667
|
+
|
|
668
|
+
// packages/experimental/src/providers/claude/index.ts
|
|
669
|
+
function createClaude() {
|
|
670
|
+
return claudeProvider(
|
|
671
|
+
async (input, init) => globalThis.fetch(
|
|
672
|
+
input,
|
|
673
|
+
withBearer(init, await getLocalClaudeAuth(requestSignal(input, init)))
|
|
674
|
+
)
|
|
675
|
+
);
|
|
676
|
+
}
|
|
191
677
|
var claude = createClaude();
|
|
192
678
|
export {
|
|
679
|
+
ClaudeAuthError,
|
|
193
680
|
claude,
|
|
194
|
-
createClaude
|
|
681
|
+
createClaude,
|
|
682
|
+
createClaudeAccounts
|
|
195
683
|
};
|
|
196
684
|
//# sourceMappingURL=index.js.map
|