@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.
Files changed (76) hide show
  1. package/README.md +8 -4
  2. package/dist/coding-agent-reminders/evaluate.d.ts.map +1 -1
  3. package/dist/coding-agent-reminders/index.js +2 -2
  4. package/dist/coding-agent-reminders/index.js.map +2 -2
  5. package/dist/index.js +233 -180
  6. package/dist/index.js.map +3 -3
  7. package/dist/providers/account-tokens.d.ts +45 -0
  8. package/dist/providers/account-tokens.d.ts.map +1 -0
  9. package/dist/providers/claude/accounts.d.ts +59 -0
  10. package/dist/providers/claude/accounts.d.ts.map +1 -0
  11. package/dist/providers/claude/errors.d.ts +7 -0
  12. package/dist/providers/claude/errors.d.ts.map +1 -0
  13. package/dist/providers/claude/index.d.ts +2 -0
  14. package/dist/providers/claude/index.d.ts.map +1 -1
  15. package/dist/providers/claude/index.js +540 -52
  16. package/dist/providers/claude/index.js.map +4 -4
  17. package/dist/providers/claude/local-credentials.d.ts.map +1 -1
  18. package/dist/providers/claude/oauth.d.ts +3 -0
  19. package/dist/providers/claude/oauth.d.ts.map +1 -0
  20. package/dist/providers/claude/provider.d.ts +4 -0
  21. package/dist/providers/claude/provider.d.ts.map +1 -0
  22. package/dist/providers/codex/accounts.d.ts +39 -0
  23. package/dist/providers/codex/accounts.d.ts.map +1 -0
  24. package/dist/providers/codex/errors.d.ts +7 -0
  25. package/dist/providers/codex/errors.d.ts.map +1 -0
  26. package/dist/providers/codex/index.d.ts +2 -0
  27. package/dist/providers/codex/index.d.ts.map +1 -1
  28. package/dist/providers/codex/index.js +472 -168
  29. package/dist/providers/codex/index.js.map +4 -4
  30. package/dist/providers/codex/local-credentials.d.ts.map +1 -1
  31. package/dist/providers/codex/provider.d.ts +3 -0
  32. package/dist/providers/codex/provider.d.ts.map +1 -0
  33. package/dist/providers/request-signal.d.ts +2 -0
  34. package/dist/providers/request-signal.d.ts.map +1 -0
  35. package/dist/zukhruf/control-plane/agent-control-plane.d.ts.map +1 -1
  36. package/dist/zukhruf/control-plane/agent-history-forker.d.ts.map +1 -1
  37. package/dist/zukhruf/index.js +231 -178
  38. package/dist/zukhruf/index.js.map +3 -3
  39. package/dist/zukhruf/mailbox/coordinator.d.ts.map +1 -1
  40. package/dist/zukhruf/mailbox/sqlite.store.d.ts.map +1 -1
  41. package/dist/zukhruf/mailbox/types.d.ts +4 -4
  42. package/dist/zukhruf/mailbox/types.d.ts.map +1 -1
  43. package/dist/zukhruf/plugins/conversation-scheduling/conversation-scheduler.d.ts.map +1 -1
  44. package/dist/zukhruf/plugins/conversation-scheduling/index.js +18 -2
  45. package/dist/zukhruf/plugins/conversation-scheduling/index.js.map +2 -2
  46. package/dist/zukhruf/plugins/http/index.js +16 -17
  47. package/dist/zukhruf/plugins/http/index.js.map +3 -3
  48. package/dist/zukhruf/plugins/http/validator.d.ts +14 -44
  49. package/dist/zukhruf/plugins/http/validator.d.ts.map +1 -1
  50. package/dist/zukhruf/plugins/schedules/http.d.ts.map +1 -1
  51. package/dist/zukhruf/plugins/schedules/http.js +22 -22
  52. package/dist/zukhruf/plugins/schedules/http.js.map +3 -3
  53. package/dist/zukhruf/plugins/schedules/index.d.ts.map +1 -1
  54. package/dist/zukhruf/plugins/schedules/index.js +173 -51
  55. package/dist/zukhruf/plugins/schedules/index.js.map +3 -3
  56. package/dist/zukhruf/plugins/schedules/scheduled-tasks.d.ts +3 -0
  57. package/dist/zukhruf/plugins/schedules/scheduled-tasks.d.ts.map +1 -1
  58. package/dist/zukhruf/plugins/uploads/http.js +17 -20
  59. package/dist/zukhruf/plugins/uploads/http.js.map +3 -3
  60. package/dist/zukhruf/plugins/uploads/index.d.ts.map +1 -1
  61. package/dist/zukhruf/plugins/uploads/index.js +1 -3
  62. package/dist/zukhruf/plugins/uploads/index.js.map +2 -2
  63. package/dist/zukhruf/queue/pg-boss-notifications.d.ts.map +1 -1
  64. package/dist/zukhruf/queue/pg-boss.turn-queue.d.ts.map +1 -1
  65. package/dist/zukhruf/render-turn.d.ts.map +1 -1
  66. package/dist/zukhruf/runtime/agent-runtime.d.ts +3 -0
  67. package/dist/zukhruf/runtime/agent-runtime.d.ts.map +1 -1
  68. package/dist/zukhruf/runtime/agent-turn-executor.d.ts.map +1 -1
  69. package/dist/zukhruf/runtime/compaction.d.ts +4 -4
  70. package/dist/zukhruf/runtime/compaction.d.ts.map +1 -1
  71. package/dist/zukhruf/runtime/conversation-status/projector.d.ts.map +1 -1
  72. package/dist/zukhruf/runtime/plugin/plugin-bindings.d.ts.map +1 -1
  73. package/dist/zukhruf/runtime/plugin/plugin-manager.d.ts.map +1 -1
  74. package/dist/zukhruf/tool.d.ts +1 -1
  75. package/dist/zukhruf/tool.d.ts.map +1 -1
  76. package/package.json +10 -10
@@ -1,156 +1,12 @@
1
1
  // packages/experimental/src/providers/codex/index.ts
2
- import { createOpenAI } from "@ai-sdk/openai";
3
2
  import {
4
- DEFAULT_CODEX_BASE_URL,
5
- createCodexFetch,
6
- resolveConfig as resolveConfig2
3
+ createCodexFetch as createCodexFetch2,
4
+ resolveConfig as resolveConfig3
7
5
  } from "@opencoredev/loginwithchatgpt-core";
8
6
 
9
- // packages/experimental/src/providers/language-model-provider.ts
10
- import { customProvider, wrapProvider } from "ai";
11
- function createLanguageModelProvider(languageModel, middleware) {
12
- const provider = wrapProvider({
13
- // The SDK rejects unsupported modalities; never expose the backing
14
- // provider's embedding or image endpoints through a subscription transport.
15
- provider: { ...customProvider({}), languageModel },
16
- languageModelMiddleware: middleware
17
- });
18
- return Object.assign(provider.languageModel, provider);
19
- }
20
-
21
- // packages/experimental/src/providers/codex/generate-via-stream.ts
22
- async function generateViaStream(streamResult) {
23
- const content = [];
24
- const warnings = [];
25
- const textParts = /* @__PURE__ */ new Map();
26
- const reasoningParts = /* @__PURE__ */ new Map();
27
- let usage = {
28
- inputTokens: {
29
- total: void 0,
30
- noCache: void 0,
31
- cacheRead: void 0,
32
- cacheWrite: void 0
33
- },
34
- outputTokens: { total: void 0, text: void 0, reasoning: void 0 }
35
- };
36
- let finishReason = {
37
- unified: "other",
38
- raw: void 0
39
- };
40
- let providerMetadata;
41
- let responseMetadata;
42
- for await (const part of streamResult.stream) {
43
- switch (part.type) {
44
- case "stream-start":
45
- warnings.push(...part.warnings);
46
- break;
47
- case "text-start": {
48
- const text = { type: "text", text: "" };
49
- if (part.providerMetadata) {
50
- text.providerMetadata = part.providerMetadata;
51
- }
52
- textParts.set(part.id, text);
53
- content.push(text);
54
- break;
55
- }
56
- case "text-delta": {
57
- const text = textParts.get(part.id);
58
- if (text) {
59
- text.text += part.delta;
60
- if (part.providerMetadata) {
61
- text.providerMetadata = part.providerMetadata;
62
- }
63
- }
64
- break;
65
- }
66
- case "text-end": {
67
- const text = textParts.get(part.id);
68
- if (text && part.providerMetadata) {
69
- text.providerMetadata = part.providerMetadata;
70
- }
71
- textParts.delete(part.id);
72
- break;
73
- }
74
- case "reasoning-start": {
75
- const reasoning = {
76
- type: "reasoning",
77
- text: ""
78
- };
79
- if (part.providerMetadata) {
80
- reasoning.providerMetadata = part.providerMetadata;
81
- }
82
- reasoningParts.set(part.id, reasoning);
83
- content.push(reasoning);
84
- break;
85
- }
86
- case "reasoning-delta": {
87
- const reasoning = reasoningParts.get(part.id);
88
- if (reasoning) {
89
- reasoning.text += part.delta;
90
- if (part.providerMetadata) {
91
- reasoning.providerMetadata = part.providerMetadata;
92
- }
93
- }
94
- break;
95
- }
96
- case "reasoning-end": {
97
- const reasoning = reasoningParts.get(part.id);
98
- if (reasoning && part.providerMetadata) {
99
- reasoning.providerMetadata = part.providerMetadata;
100
- }
101
- reasoningParts.delete(part.id);
102
- break;
103
- }
104
- case "tool-call":
105
- case "tool-result":
106
- case "tool-approval-request":
107
- case "file":
108
- case "reasoning-file":
109
- case "source":
110
- case "custom":
111
- content.push(part);
112
- break;
113
- case "response-metadata":
114
- responseMetadata = {
115
- ...part.id !== void 0 && { id: part.id },
116
- ...part.timestamp !== void 0 && { timestamp: part.timestamp },
117
- ...part.modelId !== void 0 && { modelId: part.modelId }
118
- };
119
- break;
120
- case "finish":
121
- usage = part.usage;
122
- finishReason = part.finishReason;
123
- if (part.providerMetadata) {
124
- providerMetadata = part.providerMetadata;
125
- }
126
- break;
127
- case "error":
128
- throw part.error instanceof Error ? part.error : new Error(String(part.error));
129
- // Complete tool-call parts follow the input deltas, so the deltas carry
130
- // no extra information for an aggregated result.
131
- case "tool-input-start":
132
- case "tool-input-delta":
133
- case "tool-input-end":
134
- case "raw":
135
- break;
136
- }
137
- }
138
- return {
139
- content,
140
- finishReason,
141
- usage,
142
- warnings,
143
- ...providerMetadata && { providerMetadata },
144
- ...streamResult.request && { request: streamResult.request },
145
- ...(responseMetadata ?? streamResult.response) && {
146
- response: {
147
- ...responseMetadata,
148
- ...streamResult.response?.headers && {
149
- headers: streamResult.response.headers
150
- }
151
- }
152
- }
153
- };
7
+ // packages/experimental/src/providers/request-signal.ts
8
+ function requestSignal(...[input, init]) {
9
+ return init?.signal ?? (input instanceof Request ? input.signal : void 0);
154
10
  }
155
11
 
156
12
  // packages/experimental/src/providers/codex/local-credentials.ts
@@ -162,12 +18,12 @@ import {
162
18
  isAccessTokenExpired,
163
19
  resolveConfig
164
20
  } from "@opencoredev/loginwithchatgpt-core";
21
+ import { Mutex, SqliteStore } from "@zukhruf/mutex";
165
22
  import { writeFile as atomicWriteFile } from "atomically";
166
23
  import { createHash } from "node:crypto";
167
24
  import { readFile, realpath } from "node:fs/promises";
168
25
  import { homedir } from "node:os";
169
26
  import { join, resolve } from "node:path";
170
- import { lock } from "proper-lockfile";
171
27
  import { z } from "zod";
172
28
  var nativeLogin = z.looseObject({
173
29
  auth_mode: z.literal("chatgpt"),
@@ -190,11 +46,8 @@ async function getLocalCodexAuth(signal) {
190
46
  });
191
47
  const initial = await snapshot(home);
192
48
  if (!isAccessTokenExpired(initial.tokens)) return auth(initial.tokens);
193
- const release = await lock(home, {
194
- lockfilePath: join(home, ".deepagents-chatgpt.lock"),
195
- retries: { retries: 20, minTimeout: 50, maxTimeout: 1e3 }
196
- });
197
- try {
49
+ const mutex = new Mutex(new SqliteStore(join(home, ".deepagents-locks")));
50
+ return mutex.acquire("chatgpt", async () => {
198
51
  for (let attempt = 0; attempt < 3; attempt++) {
199
52
  signal?.throwIfAborted();
200
53
  const current = await snapshot(home);
@@ -245,9 +98,7 @@ async function getLocalCodexAuth(signal) {
245
98
  throw new Error(
246
99
  "The local Codex login changed repeatedly during refresh. Retry the request."
247
100
  );
248
- } finally {
249
- await release();
250
- }
101
+ });
251
102
  }
252
103
  function auth(tokens) {
253
104
  return { accessToken: tokens.accessToken, accountId: tokens.accountId };
@@ -323,18 +174,164 @@ async function readOptionalFile(path) {
323
174
  });
324
175
  }
325
176
 
326
- // packages/experimental/src/providers/codex/index.ts
327
- function createCodex() {
177
+ // packages/experimental/src/providers/codex/provider.ts
178
+ import { createOpenAI } from "@ai-sdk/openai";
179
+ import { DEFAULT_CODEX_BASE_URL } from "@opencoredev/loginwithchatgpt-core";
180
+
181
+ // packages/experimental/src/providers/language-model-provider.ts
182
+ import { customProvider, wrapProvider } from "ai";
183
+ function createLanguageModelProvider(languageModel, middleware) {
184
+ const provider = wrapProvider({
185
+ // The SDK rejects unsupported modalities; never expose the backing
186
+ // provider's embedding or image endpoints through a subscription transport.
187
+ provider: { ...customProvider({}), languageModel },
188
+ languageModelMiddleware: middleware
189
+ });
190
+ return Object.assign(provider.languageModel, provider);
191
+ }
192
+
193
+ // packages/experimental/src/providers/codex/generate-via-stream.ts
194
+ async function generateViaStream(streamResult) {
195
+ const content = [];
196
+ const warnings = [];
197
+ const textParts = /* @__PURE__ */ new Map();
198
+ const reasoningParts = /* @__PURE__ */ new Map();
199
+ let usage = {
200
+ inputTokens: {
201
+ total: void 0,
202
+ noCache: void 0,
203
+ cacheRead: void 0,
204
+ cacheWrite: void 0
205
+ },
206
+ outputTokens: { total: void 0, text: void 0, reasoning: void 0 }
207
+ };
208
+ let finishReason = {
209
+ unified: "other",
210
+ raw: void 0
211
+ };
212
+ let providerMetadata;
213
+ let responseMetadata;
214
+ for await (const part of streamResult.stream) {
215
+ switch (part.type) {
216
+ case "stream-start":
217
+ warnings.push(...part.warnings);
218
+ break;
219
+ case "text-start": {
220
+ const text = { type: "text", text: "" };
221
+ if (part.providerMetadata) {
222
+ text.providerMetadata = part.providerMetadata;
223
+ }
224
+ textParts.set(part.id, text);
225
+ content.push(text);
226
+ break;
227
+ }
228
+ case "text-delta": {
229
+ const text = textParts.get(part.id);
230
+ if (text) {
231
+ text.text += part.delta;
232
+ if (part.providerMetadata) {
233
+ text.providerMetadata = part.providerMetadata;
234
+ }
235
+ }
236
+ break;
237
+ }
238
+ case "text-end": {
239
+ const text = textParts.get(part.id);
240
+ if (text && part.providerMetadata) {
241
+ text.providerMetadata = part.providerMetadata;
242
+ }
243
+ textParts.delete(part.id);
244
+ break;
245
+ }
246
+ case "reasoning-start": {
247
+ const reasoning = {
248
+ type: "reasoning",
249
+ text: ""
250
+ };
251
+ if (part.providerMetadata) {
252
+ reasoning.providerMetadata = part.providerMetadata;
253
+ }
254
+ reasoningParts.set(part.id, reasoning);
255
+ content.push(reasoning);
256
+ break;
257
+ }
258
+ case "reasoning-delta": {
259
+ const reasoning = reasoningParts.get(part.id);
260
+ if (reasoning) {
261
+ reasoning.text += part.delta;
262
+ if (part.providerMetadata) {
263
+ reasoning.providerMetadata = part.providerMetadata;
264
+ }
265
+ }
266
+ break;
267
+ }
268
+ case "reasoning-end": {
269
+ const reasoning = reasoningParts.get(part.id);
270
+ if (reasoning && part.providerMetadata) {
271
+ reasoning.providerMetadata = part.providerMetadata;
272
+ }
273
+ reasoningParts.delete(part.id);
274
+ break;
275
+ }
276
+ case "tool-call":
277
+ case "tool-result":
278
+ case "tool-approval-request":
279
+ case "file":
280
+ case "reasoning-file":
281
+ case "source":
282
+ case "custom":
283
+ content.push(part);
284
+ break;
285
+ case "response-metadata":
286
+ responseMetadata = {
287
+ ...part.id !== void 0 && { id: part.id },
288
+ ...part.timestamp !== void 0 && { timestamp: part.timestamp },
289
+ ...part.modelId !== void 0 && { modelId: part.modelId }
290
+ };
291
+ break;
292
+ case "finish":
293
+ usage = part.usage;
294
+ finishReason = part.finishReason;
295
+ if (part.providerMetadata) {
296
+ providerMetadata = part.providerMetadata;
297
+ }
298
+ break;
299
+ case "error":
300
+ throw part.error instanceof Error ? part.error : new Error(String(part.error));
301
+ // Complete tool-call parts follow the input deltas, so the deltas carry
302
+ // no extra information for an aggregated result.
303
+ case "tool-input-start":
304
+ case "tool-input-delta":
305
+ case "tool-input-end":
306
+ case "raw":
307
+ break;
308
+ }
309
+ }
310
+ return {
311
+ content,
312
+ finishReason,
313
+ usage,
314
+ warnings,
315
+ ...providerMetadata && { providerMetadata },
316
+ ...streamResult.request && { request: streamResult.request },
317
+ ...(responseMetadata ?? streamResult.response) && {
318
+ response: {
319
+ ...responseMetadata,
320
+ ...streamResult.response?.headers && {
321
+ headers: streamResult.response.headers
322
+ }
323
+ }
324
+ }
325
+ };
326
+ }
327
+
328
+ // packages/experimental/src/providers/codex/provider.ts
329
+ function codexProvider(fetch) {
328
330
  const provider = createOpenAI({
329
331
  name: "codex",
330
332
  baseURL: DEFAULT_CODEX_BASE_URL,
331
- apiKey: "injected-by-local-chatgpt-transport",
332
- fetch: (input, init) => createCodexFetch({
333
- config: resolveConfig2(),
334
- getAuth: () => getLocalCodexAuth(
335
- init?.signal ?? (input instanceof Request ? input.signal : void 0)
336
- )
337
- })(input, init)
333
+ apiKey: "injected-by-chatgpt-transport",
334
+ fetch
338
335
  });
339
336
  return createLanguageModelProvider(provider.responses, {
340
337
  specificationVersion: "v4",
@@ -350,9 +347,316 @@ function createCodex() {
350
347
  wrapGenerate: async ({ doStream }) => generateViaStream(await doStream())
351
348
  });
352
349
  }
350
+
351
+ // packages/experimental/src/providers/codex/accounts.ts
352
+ import {
353
+ createCodexFetch,
354
+ deriveAccountId as deriveAccountId2,
355
+ ensureFreshTokens as ensureFreshTokens2,
356
+ extractCodexModelSlugs,
357
+ isAccessTokenExpired as isAccessTokenExpired2,
358
+ isRefreshTokenInvalid,
359
+ parseUser,
360
+ requestDeviceCode,
361
+ resolveConfig as resolveConfig2,
362
+ waitForDeviceTokens
363
+ } from "@opencoredev/loginwithchatgpt-core";
364
+ import { z as z2 } from "zod";
365
+
366
+ // packages/experimental/src/providers/account-tokens.ts
367
+ import { MemoryStore, Mutex as Mutex2 } from "@zukhruf/mutex";
368
+ function createTokenVault(store, parse2) {
369
+ const revisions = /* @__PURE__ */ new Map();
370
+ const serialized = new Mutex2(new MemoryStore());
371
+ const revision = (owner) => revisions.get(owner) ?? 0;
372
+ return {
373
+ snapshot: (owner) => serialized.acquire(owner, async () => ({
374
+ tokens: parse2(await store.get(owner)),
375
+ revision: revision(owner)
376
+ })),
377
+ commit: (owner, tokens, expectedRevision) => serialized.acquire(owner, async () => {
378
+ if (revision(owner) !== expectedRevision) return false;
379
+ await store.set(owner, tokens);
380
+ revisions.set(owner, revision(owner) + 1);
381
+ return true;
382
+ }),
383
+ clear: (owner, expectedRevision) => serialized.acquire(owner, async () => {
384
+ if (expectedRevision !== void 0 && revision(owner) !== expectedRevision) {
385
+ return false;
386
+ }
387
+ await store.delete(owner);
388
+ revisions.set(owner, revision(owner) + 1);
389
+ return true;
390
+ })
391
+ };
392
+ }
393
+ function createTokenResolver(options) {
394
+ const exclusive = new Mutex2(new MemoryStore());
395
+ async function resolve2(owner, rejected, signal) {
396
+ for (let attempt = 0; attempt < 3; attempt++) {
397
+ signal?.throwIfAborted();
398
+ const { tokens, revision } = await options.vault.snapshot(owner);
399
+ if (!tokens) throw options.notConnected();
400
+ if (tokens.accessToken !== rejected && options.isFresh(tokens)) {
401
+ return tokens;
402
+ }
403
+ const result = await options.refresh(tokens);
404
+ if (result.status === "revoked") {
405
+ if (!await options.vault.clear(owner, revision)) continue;
406
+ options.onRevoked(owner);
407
+ throw options.revoked();
408
+ }
409
+ if (await options.vault.commit(owner, result.tokens, revision)) {
410
+ return result.tokens;
411
+ }
412
+ }
413
+ throw options.conflicted();
414
+ }
415
+ return {
416
+ fresh: (owner, signal) => exclusive.acquire(owner, () => resolve2(owner, void 0, signal)),
417
+ /** Replaces an access token the server rejected, refreshing at most once. */
418
+ replace: (owner, rejected, signal) => exclusive.acquire(owner, () => resolve2(owner, rejected, signal))
419
+ };
420
+ }
421
+ async function retryUnauthorized(credential, send, replace, rejectedAgain) {
422
+ const response = await send(credential);
423
+ if (response.status !== 401) return response;
424
+ await response.body?.cancel();
425
+ const retry = await send(await replace(credential));
426
+ if (retry.status !== 401) return retry;
427
+ await retry.body?.cancel();
428
+ throw rejectedAgain();
429
+ }
430
+
431
+ // packages/experimental/src/providers/codex/errors.ts
432
+ var CodexAuthError = class extends Error {
433
+ code;
434
+ constructor(code, message) {
435
+ super(message);
436
+ this.name = "CodexAuthError";
437
+ this.code = code;
438
+ }
439
+ };
440
+
441
+ // packages/experimental/src/providers/codex/accounts.ts
442
+ var REQUEST_TIMEOUT_MS = 3e4;
443
+ var chatgptTokens = z2.object({
444
+ accessToken: z2.string().min(1),
445
+ refreshToken: z2.string().min(1).optional(),
446
+ idToken: z2.string().optional(),
447
+ accountId: z2.string().optional(),
448
+ expiresAt: z2.number().optional()
449
+ });
450
+ function createCodexAccounts(options) {
451
+ const vault = createTokenVault(
452
+ options.store,
453
+ (value) => chatgptTokens.safeParse(value).data
454
+ );
455
+ const signIns = /* @__PURE__ */ new Map();
456
+ const tokens = createTokenResolver({
457
+ vault,
458
+ isFresh: (current) => !isAccessTokenExpired2(current),
459
+ refresh: refreshTokens,
460
+ notConnected: () => new CodexAuthError(
461
+ "not-connected",
462
+ "No ChatGPT account is connected. Connect one before using this model."
463
+ ),
464
+ revoked: () => new CodexAuthError(
465
+ "refresh-token-invalid",
466
+ "The ChatGPT connection expired or was revoked. Connect the account again."
467
+ ),
468
+ conflicted: () => new CodexAuthError(
469
+ "refresh-failed",
470
+ "The ChatGPT connection changed repeatedly during refresh. Retry the request."
471
+ ),
472
+ onRevoked: (owner) => void publish(owner)
473
+ });
474
+ function authorizedFetch(owner) {
475
+ return async (input, init) => {
476
+ const signal = requestSignal(input, init);
477
+ const config = resolveConfig2();
478
+ return retryUnauthorized(
479
+ codexAuth(await tokens.fresh(owner, signal)),
480
+ (auth2) => createCodexFetch({ config, getAuth: () => auth2 })(input, init),
481
+ async (rejected) => codexAuth(await tokens.replace(owner, rejected.accessToken, signal)),
482
+ () => new CodexAuthError(
483
+ "access-token-invalid",
484
+ "OpenAI rejected the ChatGPT connection. Connect the account again."
485
+ )
486
+ );
487
+ };
488
+ }
489
+ async function state(owner) {
490
+ const signIn = signIns.get(owner);
491
+ if (signIn) return pending(signIn);
492
+ try {
493
+ const { tokens: current } = await vault.snapshot(owner);
494
+ if (!current) return { status: "unauthenticated" };
495
+ return { status: "connected", user: parseUser(current.idToken) ?? null };
496
+ } catch (error) {
497
+ return {
498
+ status: "error",
499
+ message: messageOf(error, "Reading the ChatGPT connection failed.")
500
+ };
501
+ }
502
+ }
503
+ function emit(owner, current) {
504
+ options.onChange?.(owner, current);
505
+ return current;
506
+ }
507
+ async function publish(owner) {
508
+ return emit(owner, await state(owner));
509
+ }
510
+ function cancel(owner) {
511
+ const signIn = signIns.get(owner);
512
+ if (!signIn) return;
513
+ signIns.delete(owner);
514
+ signIn.abort.abort();
515
+ }
516
+ async function waitForSignIn(owner, signIn, config, device) {
517
+ try {
518
+ const fresh = await waitForDeviceTokens(config, device, {
519
+ signal: signIn.abort.signal
520
+ });
521
+ if (signIns.get(owner) === signIn) {
522
+ await vault.commit(owner, fresh, signIn.revision);
523
+ }
524
+ } catch (error) {
525
+ if (signIns.get(owner) === signIn) {
526
+ signIns.delete(owner);
527
+ emit(owner, {
528
+ status: "error",
529
+ message: messageOf(error, "ChatGPT sign-in failed.")
530
+ });
531
+ return;
532
+ }
533
+ }
534
+ if (signIns.get(owner) === signIn) signIns.delete(owner);
535
+ await publish(owner);
536
+ }
537
+ async function connect(owner) {
538
+ const existing = await state(owner);
539
+ if (existing.status !== "unauthenticated") return existing;
540
+ const { revision } = await vault.snapshot(owner);
541
+ const abort = new AbortController();
542
+ const config = resolveConfig2({
543
+ fetch: (input, init) => {
544
+ const signal = requestSignal(input, init);
545
+ return globalThis.fetch(input, {
546
+ ...init,
547
+ signal: signal ? AbortSignal.any([signal, abort.signal]) : abort.signal
548
+ });
549
+ }
550
+ });
551
+ let device;
552
+ try {
553
+ device = await requestDeviceCode(config);
554
+ } catch (error) {
555
+ return emit(owner, {
556
+ status: "error",
557
+ message: messageOf(error, "ChatGPT sign-in failed.")
558
+ });
559
+ }
560
+ cancel(owner);
561
+ const signIn = {
562
+ userCode: device.userCode,
563
+ verificationUrl: device.verificationUrl,
564
+ expiresAt: new Date(device.expiresAt).toISOString(),
565
+ revision,
566
+ abort
567
+ };
568
+ signIns.set(owner, signIn);
569
+ const current = emit(owner, pending(signIn));
570
+ void waitForSignIn(owner, signIn, config, device);
571
+ return current;
572
+ }
573
+ async function disconnect(owner) {
574
+ cancel(owner);
575
+ await vault.clear(owner);
576
+ return publish(owner);
577
+ }
578
+ async function listModels(owner, signal) {
579
+ const response = await authorizedFetch(owner)(
580
+ `${resolveConfig2().codexBaseUrl}/models`,
581
+ { method: "GET", headers: { accept: "application/json" }, signal }
582
+ );
583
+ if (!response.ok) {
584
+ await response.body?.cancel();
585
+ throw new CodexAuthError(
586
+ "models-request-failed",
587
+ `Listing ChatGPT models failed (${response.status}).`
588
+ );
589
+ }
590
+ return extractCodexModelSlugs(await response.json());
591
+ }
592
+ return {
593
+ /** AI SDK models authenticated as this owner's ChatGPT account. */
594
+ provider: (owner) => codexProvider(authorizedFetch(owner)),
595
+ /** Model slugs this owner's account can run. */
596
+ listModels,
597
+ state,
598
+ connect,
599
+ /** Abandons an in-flight sign-in, for example when the owner signs out. */
600
+ cancel,
601
+ disconnect
602
+ };
603
+ }
604
+ function pending(signIn) {
605
+ return {
606
+ status: "pending",
607
+ userCode: signIn.userCode,
608
+ verificationUrl: signIn.verificationUrl,
609
+ expiresAt: signIn.expiresAt
610
+ };
611
+ }
612
+ function codexAuth(tokens) {
613
+ const accountId = tokens.accountId ?? deriveAccountId2(tokens.idToken) ?? deriveAccountId2(tokens.accessToken);
614
+ if (!accountId) {
615
+ throw new CodexAuthError(
616
+ "missing-account-id",
617
+ "The ChatGPT connection has no account identifier. Connect the account again."
618
+ );
619
+ }
620
+ return { accessToken: tokens.accessToken, accountId };
621
+ }
622
+ async function refreshTokens(current) {
623
+ const config = resolveConfig2({
624
+ fetch: (input, init) => globalThis.fetch(input, {
625
+ ...init,
626
+ signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
627
+ })
628
+ });
629
+ try {
630
+ return {
631
+ status: "refreshed",
632
+ tokens: await ensureFreshTokens2(config, current, { force: true })
633
+ };
634
+ } catch (error) {
635
+ if (isRefreshTokenInvalid(error)) return { status: "revoked" };
636
+ throw new CodexAuthError(
637
+ "refresh-failed",
638
+ "Could not refresh the ChatGPT connection. Retry the request."
639
+ );
640
+ }
641
+ }
642
+ function messageOf(error, fallback) {
643
+ return error instanceof Error ? error.message : fallback;
644
+ }
645
+
646
+ // packages/experimental/src/providers/codex/index.ts
647
+ function createCodex() {
648
+ return codexProvider(
649
+ (input, init) => createCodexFetch2({
650
+ config: resolveConfig3(),
651
+ getAuth: () => getLocalCodexAuth(requestSignal(input, init))
652
+ })(input, init)
653
+ );
654
+ }
353
655
  var codex = createCodex();
354
656
  export {
657
+ CodexAuthError,
355
658
  codex,
356
- createCodex
659
+ createCodex,
660
+ createCodexAccounts
357
661
  };
358
662
  //# sourceMappingURL=index.js.map