@deepagents/experimental 7.0.2 → 7.1.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 +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 +230 -172
- package/dist/index.js.map +3 -3
- package/dist/providers/account-tokens.d.ts +47 -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 +550 -43
- 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 +482 -159
- package/dist/providers/codex/index.js.map +4 -4
- 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 +228 -170
- 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 +17 -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 +172 -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 +6 -5
|
@@ -1,156 +1,12 @@
|
|
|
1
1
|
// packages/experimental/src/providers/codex/index.ts
|
|
2
|
-
import { createOpenAI } from "@ai-sdk/openai";
|
|
3
2
|
import {
|
|
4
|
-
|
|
5
|
-
|
|
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/
|
|
10
|
-
|
|
11
|
-
|
|
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
|
|
@@ -323,18 +179,164 @@ async function readOptionalFile(path) {
|
|
|
323
179
|
});
|
|
324
180
|
}
|
|
325
181
|
|
|
326
|
-
// packages/experimental/src/providers/codex/
|
|
327
|
-
|
|
182
|
+
// packages/experimental/src/providers/codex/provider.ts
|
|
183
|
+
import { createOpenAI } from "@ai-sdk/openai";
|
|
184
|
+
import { DEFAULT_CODEX_BASE_URL } from "@opencoredev/loginwithchatgpt-core";
|
|
185
|
+
|
|
186
|
+
// packages/experimental/src/providers/language-model-provider.ts
|
|
187
|
+
import { customProvider, wrapProvider } from "ai";
|
|
188
|
+
function createLanguageModelProvider(languageModel, middleware) {
|
|
189
|
+
const provider = wrapProvider({
|
|
190
|
+
// The SDK rejects unsupported modalities; never expose the backing
|
|
191
|
+
// provider's embedding or image endpoints through a subscription transport.
|
|
192
|
+
provider: { ...customProvider({}), languageModel },
|
|
193
|
+
languageModelMiddleware: middleware
|
|
194
|
+
});
|
|
195
|
+
return Object.assign(provider.languageModel, provider);
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
// packages/experimental/src/providers/codex/generate-via-stream.ts
|
|
199
|
+
async function generateViaStream(streamResult) {
|
|
200
|
+
const content = [];
|
|
201
|
+
const warnings = [];
|
|
202
|
+
const textParts = /* @__PURE__ */ new Map();
|
|
203
|
+
const reasoningParts = /* @__PURE__ */ new Map();
|
|
204
|
+
let usage = {
|
|
205
|
+
inputTokens: {
|
|
206
|
+
total: void 0,
|
|
207
|
+
noCache: void 0,
|
|
208
|
+
cacheRead: void 0,
|
|
209
|
+
cacheWrite: void 0
|
|
210
|
+
},
|
|
211
|
+
outputTokens: { total: void 0, text: void 0, reasoning: void 0 }
|
|
212
|
+
};
|
|
213
|
+
let finishReason = {
|
|
214
|
+
unified: "other",
|
|
215
|
+
raw: void 0
|
|
216
|
+
};
|
|
217
|
+
let providerMetadata;
|
|
218
|
+
let responseMetadata;
|
|
219
|
+
for await (const part of streamResult.stream) {
|
|
220
|
+
switch (part.type) {
|
|
221
|
+
case "stream-start":
|
|
222
|
+
warnings.push(...part.warnings);
|
|
223
|
+
break;
|
|
224
|
+
case "text-start": {
|
|
225
|
+
const text = { type: "text", text: "" };
|
|
226
|
+
if (part.providerMetadata) {
|
|
227
|
+
text.providerMetadata = part.providerMetadata;
|
|
228
|
+
}
|
|
229
|
+
textParts.set(part.id, text);
|
|
230
|
+
content.push(text);
|
|
231
|
+
break;
|
|
232
|
+
}
|
|
233
|
+
case "text-delta": {
|
|
234
|
+
const text = textParts.get(part.id);
|
|
235
|
+
if (text) {
|
|
236
|
+
text.text += part.delta;
|
|
237
|
+
if (part.providerMetadata) {
|
|
238
|
+
text.providerMetadata = part.providerMetadata;
|
|
239
|
+
}
|
|
240
|
+
}
|
|
241
|
+
break;
|
|
242
|
+
}
|
|
243
|
+
case "text-end": {
|
|
244
|
+
const text = textParts.get(part.id);
|
|
245
|
+
if (text && part.providerMetadata) {
|
|
246
|
+
text.providerMetadata = part.providerMetadata;
|
|
247
|
+
}
|
|
248
|
+
textParts.delete(part.id);
|
|
249
|
+
break;
|
|
250
|
+
}
|
|
251
|
+
case "reasoning-start": {
|
|
252
|
+
const reasoning = {
|
|
253
|
+
type: "reasoning",
|
|
254
|
+
text: ""
|
|
255
|
+
};
|
|
256
|
+
if (part.providerMetadata) {
|
|
257
|
+
reasoning.providerMetadata = part.providerMetadata;
|
|
258
|
+
}
|
|
259
|
+
reasoningParts.set(part.id, reasoning);
|
|
260
|
+
content.push(reasoning);
|
|
261
|
+
break;
|
|
262
|
+
}
|
|
263
|
+
case "reasoning-delta": {
|
|
264
|
+
const reasoning = reasoningParts.get(part.id);
|
|
265
|
+
if (reasoning) {
|
|
266
|
+
reasoning.text += part.delta;
|
|
267
|
+
if (part.providerMetadata) {
|
|
268
|
+
reasoning.providerMetadata = part.providerMetadata;
|
|
269
|
+
}
|
|
270
|
+
}
|
|
271
|
+
break;
|
|
272
|
+
}
|
|
273
|
+
case "reasoning-end": {
|
|
274
|
+
const reasoning = reasoningParts.get(part.id);
|
|
275
|
+
if (reasoning && part.providerMetadata) {
|
|
276
|
+
reasoning.providerMetadata = part.providerMetadata;
|
|
277
|
+
}
|
|
278
|
+
reasoningParts.delete(part.id);
|
|
279
|
+
break;
|
|
280
|
+
}
|
|
281
|
+
case "tool-call":
|
|
282
|
+
case "tool-result":
|
|
283
|
+
case "tool-approval-request":
|
|
284
|
+
case "file":
|
|
285
|
+
case "reasoning-file":
|
|
286
|
+
case "source":
|
|
287
|
+
case "custom":
|
|
288
|
+
content.push(part);
|
|
289
|
+
break;
|
|
290
|
+
case "response-metadata":
|
|
291
|
+
responseMetadata = {
|
|
292
|
+
...part.id !== void 0 && { id: part.id },
|
|
293
|
+
...part.timestamp !== void 0 && { timestamp: part.timestamp },
|
|
294
|
+
...part.modelId !== void 0 && { modelId: part.modelId }
|
|
295
|
+
};
|
|
296
|
+
break;
|
|
297
|
+
case "finish":
|
|
298
|
+
usage = part.usage;
|
|
299
|
+
finishReason = part.finishReason;
|
|
300
|
+
if (part.providerMetadata) {
|
|
301
|
+
providerMetadata = part.providerMetadata;
|
|
302
|
+
}
|
|
303
|
+
break;
|
|
304
|
+
case "error":
|
|
305
|
+
throw part.error instanceof Error ? part.error : new Error(String(part.error));
|
|
306
|
+
// Complete tool-call parts follow the input deltas, so the deltas carry
|
|
307
|
+
// no extra information for an aggregated result.
|
|
308
|
+
case "tool-input-start":
|
|
309
|
+
case "tool-input-delta":
|
|
310
|
+
case "tool-input-end":
|
|
311
|
+
case "raw":
|
|
312
|
+
break;
|
|
313
|
+
}
|
|
314
|
+
}
|
|
315
|
+
return {
|
|
316
|
+
content,
|
|
317
|
+
finishReason,
|
|
318
|
+
usage,
|
|
319
|
+
warnings,
|
|
320
|
+
...providerMetadata && { providerMetadata },
|
|
321
|
+
...streamResult.request && { request: streamResult.request },
|
|
322
|
+
...(responseMetadata ?? streamResult.response) && {
|
|
323
|
+
response: {
|
|
324
|
+
...responseMetadata,
|
|
325
|
+
...streamResult.response?.headers && {
|
|
326
|
+
headers: streamResult.response.headers
|
|
327
|
+
}
|
|
328
|
+
}
|
|
329
|
+
}
|
|
330
|
+
};
|
|
331
|
+
}
|
|
332
|
+
|
|
333
|
+
// packages/experimental/src/providers/codex/provider.ts
|
|
334
|
+
function codexProvider(fetch) {
|
|
328
335
|
const provider = createOpenAI({
|
|
329
336
|
name: "codex",
|
|
330
337
|
baseURL: DEFAULT_CODEX_BASE_URL,
|
|
331
|
-
apiKey: "injected-by-
|
|
332
|
-
fetch
|
|
333
|
-
config: resolveConfig2(),
|
|
334
|
-
getAuth: () => getLocalCodexAuth(
|
|
335
|
-
init?.signal ?? (input instanceof Request ? input.signal : void 0)
|
|
336
|
-
)
|
|
337
|
-
})(input, init)
|
|
338
|
+
apiKey: "injected-by-chatgpt-transport",
|
|
339
|
+
fetch
|
|
338
340
|
});
|
|
339
341
|
return createLanguageModelProvider(provider.responses, {
|
|
340
342
|
specificationVersion: "v4",
|
|
@@ -350,9 +352,330 @@ function createCodex() {
|
|
|
350
352
|
wrapGenerate: async ({ doStream }) => generateViaStream(await doStream())
|
|
351
353
|
});
|
|
352
354
|
}
|
|
355
|
+
|
|
356
|
+
// packages/experimental/src/providers/codex/accounts.ts
|
|
357
|
+
import {
|
|
358
|
+
createCodexFetch,
|
|
359
|
+
deriveAccountId as deriveAccountId2,
|
|
360
|
+
ensureFreshTokens as ensureFreshTokens2,
|
|
361
|
+
extractCodexModelSlugs,
|
|
362
|
+
isAccessTokenExpired as isAccessTokenExpired2,
|
|
363
|
+
isRefreshTokenInvalid,
|
|
364
|
+
parseUser,
|
|
365
|
+
requestDeviceCode,
|
|
366
|
+
resolveConfig as resolveConfig2,
|
|
367
|
+
waitForDeviceTokens
|
|
368
|
+
} from "@opencoredev/loginwithchatgpt-core";
|
|
369
|
+
import { z as z2 } from "zod";
|
|
370
|
+
|
|
371
|
+
// packages/experimental/src/providers/account-tokens.ts
|
|
372
|
+
function createKeyedQueue() {
|
|
373
|
+
const tails = /* @__PURE__ */ new Map();
|
|
374
|
+
return function run(key, operation) {
|
|
375
|
+
const result = (tails.get(key) ?? Promise.resolve()).then(operation);
|
|
376
|
+
const tail = result.then(
|
|
377
|
+
() => void 0,
|
|
378
|
+
() => void 0
|
|
379
|
+
);
|
|
380
|
+
tails.set(key, tail);
|
|
381
|
+
void tail.then(() => {
|
|
382
|
+
if (tails.get(key) === tail) tails.delete(key);
|
|
383
|
+
});
|
|
384
|
+
return result;
|
|
385
|
+
};
|
|
386
|
+
}
|
|
387
|
+
function createTokenVault(store, parse2) {
|
|
388
|
+
const revisions = /* @__PURE__ */ new Map();
|
|
389
|
+
const serialized = createKeyedQueue();
|
|
390
|
+
const revision = (owner) => revisions.get(owner) ?? 0;
|
|
391
|
+
return {
|
|
392
|
+
snapshot: (owner) => serialized(owner, async () => ({
|
|
393
|
+
tokens: parse2(await store.get(owner)),
|
|
394
|
+
revision: revision(owner)
|
|
395
|
+
})),
|
|
396
|
+
commit: (owner, tokens, expectedRevision) => serialized(owner, async () => {
|
|
397
|
+
if (revision(owner) !== expectedRevision) return false;
|
|
398
|
+
await store.set(owner, tokens);
|
|
399
|
+
revisions.set(owner, revision(owner) + 1);
|
|
400
|
+
return true;
|
|
401
|
+
}),
|
|
402
|
+
clear: (owner, expectedRevision) => serialized(owner, async () => {
|
|
403
|
+
if (expectedRevision !== void 0 && revision(owner) !== expectedRevision) {
|
|
404
|
+
return false;
|
|
405
|
+
}
|
|
406
|
+
await store.delete(owner);
|
|
407
|
+
revisions.set(owner, revision(owner) + 1);
|
|
408
|
+
return true;
|
|
409
|
+
})
|
|
410
|
+
};
|
|
411
|
+
}
|
|
412
|
+
function createTokenResolver(options) {
|
|
413
|
+
const exclusive = createKeyedQueue();
|
|
414
|
+
async function resolve2(owner, rejected, signal) {
|
|
415
|
+
for (let attempt = 0; attempt < 3; attempt++) {
|
|
416
|
+
signal?.throwIfAborted();
|
|
417
|
+
const { tokens, revision } = await options.vault.snapshot(owner);
|
|
418
|
+
if (!tokens) throw options.notConnected();
|
|
419
|
+
if (tokens.accessToken !== rejected && options.isFresh(tokens)) {
|
|
420
|
+
return tokens;
|
|
421
|
+
}
|
|
422
|
+
const result = await options.refresh(tokens);
|
|
423
|
+
if (result.status === "revoked") {
|
|
424
|
+
if (!await options.vault.clear(owner, revision)) continue;
|
|
425
|
+
options.onRevoked(owner);
|
|
426
|
+
throw options.revoked();
|
|
427
|
+
}
|
|
428
|
+
if (await options.vault.commit(owner, result.tokens, revision)) {
|
|
429
|
+
return result.tokens;
|
|
430
|
+
}
|
|
431
|
+
}
|
|
432
|
+
throw options.conflicted();
|
|
433
|
+
}
|
|
434
|
+
return {
|
|
435
|
+
fresh: (owner, signal) => exclusive(owner, () => resolve2(owner, void 0, signal)),
|
|
436
|
+
/** Replaces an access token the server rejected, refreshing at most once. */
|
|
437
|
+
replace: (owner, rejected, signal) => exclusive(owner, () => resolve2(owner, rejected, signal))
|
|
438
|
+
};
|
|
439
|
+
}
|
|
440
|
+
async function retryUnauthorized(credential, send, replace, rejectedAgain) {
|
|
441
|
+
const response = await send(credential);
|
|
442
|
+
if (response.status !== 401) return response;
|
|
443
|
+
await response.body?.cancel();
|
|
444
|
+
const retry = await send(await replace(credential));
|
|
445
|
+
if (retry.status !== 401) return retry;
|
|
446
|
+
await retry.body?.cancel();
|
|
447
|
+
throw rejectedAgain();
|
|
448
|
+
}
|
|
449
|
+
|
|
450
|
+
// packages/experimental/src/providers/codex/errors.ts
|
|
451
|
+
var CodexAuthError = class extends Error {
|
|
452
|
+
code;
|
|
453
|
+
constructor(code, message) {
|
|
454
|
+
super(message);
|
|
455
|
+
this.name = "CodexAuthError";
|
|
456
|
+
this.code = code;
|
|
457
|
+
}
|
|
458
|
+
};
|
|
459
|
+
|
|
460
|
+
// packages/experimental/src/providers/codex/accounts.ts
|
|
461
|
+
var REQUEST_TIMEOUT_MS = 3e4;
|
|
462
|
+
var chatgptTokens = z2.object({
|
|
463
|
+
accessToken: z2.string().min(1),
|
|
464
|
+
refreshToken: z2.string().min(1).optional(),
|
|
465
|
+
idToken: z2.string().optional(),
|
|
466
|
+
accountId: z2.string().optional(),
|
|
467
|
+
expiresAt: z2.number().optional()
|
|
468
|
+
});
|
|
469
|
+
function createCodexAccounts(options) {
|
|
470
|
+
const vault = createTokenVault(
|
|
471
|
+
options.store,
|
|
472
|
+
(value) => chatgptTokens.safeParse(value).data
|
|
473
|
+
);
|
|
474
|
+
const signIns = /* @__PURE__ */ new Map();
|
|
475
|
+
const tokens = createTokenResolver({
|
|
476
|
+
vault,
|
|
477
|
+
isFresh: (current) => !isAccessTokenExpired2(current),
|
|
478
|
+
refresh: refreshTokens,
|
|
479
|
+
notConnected: () => new CodexAuthError(
|
|
480
|
+
"not-connected",
|
|
481
|
+
"No ChatGPT account is connected. Connect one before using this model."
|
|
482
|
+
),
|
|
483
|
+
revoked: () => new CodexAuthError(
|
|
484
|
+
"refresh-token-invalid",
|
|
485
|
+
"The ChatGPT connection expired or was revoked. Connect the account again."
|
|
486
|
+
),
|
|
487
|
+
conflicted: () => new CodexAuthError(
|
|
488
|
+
"refresh-failed",
|
|
489
|
+
"The ChatGPT connection changed repeatedly during refresh. Retry the request."
|
|
490
|
+
),
|
|
491
|
+
onRevoked: (owner) => void publish(owner)
|
|
492
|
+
});
|
|
493
|
+
function authorizedFetch(owner) {
|
|
494
|
+
return async (input, init) => {
|
|
495
|
+
const signal = requestSignal(input, init);
|
|
496
|
+
const config = resolveConfig2();
|
|
497
|
+
return retryUnauthorized(
|
|
498
|
+
codexAuth(await tokens.fresh(owner, signal)),
|
|
499
|
+
(auth2) => createCodexFetch({ config, getAuth: () => auth2 })(input, init),
|
|
500
|
+
async (rejected) => codexAuth(await tokens.replace(owner, rejected.accessToken, signal)),
|
|
501
|
+
() => new CodexAuthError(
|
|
502
|
+
"access-token-invalid",
|
|
503
|
+
"OpenAI rejected the ChatGPT connection. Connect the account again."
|
|
504
|
+
)
|
|
505
|
+
);
|
|
506
|
+
};
|
|
507
|
+
}
|
|
508
|
+
async function state(owner) {
|
|
509
|
+
const signIn = signIns.get(owner);
|
|
510
|
+
if (signIn) return pending(signIn);
|
|
511
|
+
try {
|
|
512
|
+
const { tokens: current } = await vault.snapshot(owner);
|
|
513
|
+
if (!current) return { status: "unauthenticated" };
|
|
514
|
+
return { status: "connected", user: parseUser(current.idToken) ?? null };
|
|
515
|
+
} catch (error) {
|
|
516
|
+
return {
|
|
517
|
+
status: "error",
|
|
518
|
+
message: messageOf(error, "Reading the ChatGPT connection failed.")
|
|
519
|
+
};
|
|
520
|
+
}
|
|
521
|
+
}
|
|
522
|
+
function emit(owner, current) {
|
|
523
|
+
options.onChange?.(owner, current);
|
|
524
|
+
return current;
|
|
525
|
+
}
|
|
526
|
+
async function publish(owner) {
|
|
527
|
+
return emit(owner, await state(owner));
|
|
528
|
+
}
|
|
529
|
+
function cancel(owner) {
|
|
530
|
+
const signIn = signIns.get(owner);
|
|
531
|
+
if (!signIn) return;
|
|
532
|
+
signIns.delete(owner);
|
|
533
|
+
signIn.abort.abort();
|
|
534
|
+
}
|
|
535
|
+
async function waitForSignIn(owner, signIn, config, device) {
|
|
536
|
+
try {
|
|
537
|
+
const fresh = await waitForDeviceTokens(config, device, {
|
|
538
|
+
signal: signIn.abort.signal
|
|
539
|
+
});
|
|
540
|
+
if (signIns.get(owner) === signIn) {
|
|
541
|
+
await vault.commit(owner, fresh, signIn.revision);
|
|
542
|
+
}
|
|
543
|
+
} catch (error) {
|
|
544
|
+
if (signIns.get(owner) === signIn) {
|
|
545
|
+
signIns.delete(owner);
|
|
546
|
+
emit(owner, {
|
|
547
|
+
status: "error",
|
|
548
|
+
message: messageOf(error, "ChatGPT sign-in failed.")
|
|
549
|
+
});
|
|
550
|
+
return;
|
|
551
|
+
}
|
|
552
|
+
}
|
|
553
|
+
if (signIns.get(owner) === signIn) signIns.delete(owner);
|
|
554
|
+
await publish(owner);
|
|
555
|
+
}
|
|
556
|
+
async function connect(owner) {
|
|
557
|
+
const existing = await state(owner);
|
|
558
|
+
if (existing.status !== "unauthenticated") return existing;
|
|
559
|
+
const { revision } = await vault.snapshot(owner);
|
|
560
|
+
const abort = new AbortController();
|
|
561
|
+
const config = resolveConfig2({
|
|
562
|
+
fetch: (input, init) => {
|
|
563
|
+
const signal = requestSignal(input, init);
|
|
564
|
+
return globalThis.fetch(input, {
|
|
565
|
+
...init,
|
|
566
|
+
signal: signal ? AbortSignal.any([signal, abort.signal]) : abort.signal
|
|
567
|
+
});
|
|
568
|
+
}
|
|
569
|
+
});
|
|
570
|
+
let device;
|
|
571
|
+
try {
|
|
572
|
+
device = await requestDeviceCode(config);
|
|
573
|
+
} catch (error) {
|
|
574
|
+
return emit(owner, {
|
|
575
|
+
status: "error",
|
|
576
|
+
message: messageOf(error, "ChatGPT sign-in failed.")
|
|
577
|
+
});
|
|
578
|
+
}
|
|
579
|
+
cancel(owner);
|
|
580
|
+
const signIn = {
|
|
581
|
+
userCode: device.userCode,
|
|
582
|
+
verificationUrl: device.verificationUrl,
|
|
583
|
+
expiresAt: new Date(device.expiresAt).toISOString(),
|
|
584
|
+
revision,
|
|
585
|
+
abort
|
|
586
|
+
};
|
|
587
|
+
signIns.set(owner, signIn);
|
|
588
|
+
const current = emit(owner, pending(signIn));
|
|
589
|
+
void waitForSignIn(owner, signIn, config, device);
|
|
590
|
+
return current;
|
|
591
|
+
}
|
|
592
|
+
async function disconnect(owner) {
|
|
593
|
+
cancel(owner);
|
|
594
|
+
await vault.clear(owner);
|
|
595
|
+
return publish(owner);
|
|
596
|
+
}
|
|
597
|
+
async function listModels(owner, signal) {
|
|
598
|
+
const response = await authorizedFetch(owner)(
|
|
599
|
+
`${resolveConfig2().codexBaseUrl}/models`,
|
|
600
|
+
{ method: "GET", headers: { accept: "application/json" }, signal }
|
|
601
|
+
);
|
|
602
|
+
if (!response.ok) {
|
|
603
|
+
await response.body?.cancel();
|
|
604
|
+
throw new CodexAuthError(
|
|
605
|
+
"models-request-failed",
|
|
606
|
+
`Listing ChatGPT models failed (${response.status}).`
|
|
607
|
+
);
|
|
608
|
+
}
|
|
609
|
+
return extractCodexModelSlugs(await response.json());
|
|
610
|
+
}
|
|
611
|
+
return {
|
|
612
|
+
/** AI SDK models authenticated as this owner's ChatGPT account. */
|
|
613
|
+
provider: (owner) => codexProvider(authorizedFetch(owner)),
|
|
614
|
+
/** Model slugs this owner's account can run. */
|
|
615
|
+
listModels,
|
|
616
|
+
state,
|
|
617
|
+
connect,
|
|
618
|
+
/** Abandons an in-flight sign-in, for example when the owner signs out. */
|
|
619
|
+
cancel,
|
|
620
|
+
disconnect
|
|
621
|
+
};
|
|
622
|
+
}
|
|
623
|
+
function pending(signIn) {
|
|
624
|
+
return {
|
|
625
|
+
status: "pending",
|
|
626
|
+
userCode: signIn.userCode,
|
|
627
|
+
verificationUrl: signIn.verificationUrl,
|
|
628
|
+
expiresAt: signIn.expiresAt
|
|
629
|
+
};
|
|
630
|
+
}
|
|
631
|
+
function codexAuth(tokens) {
|
|
632
|
+
const accountId = tokens.accountId ?? deriveAccountId2(tokens.idToken) ?? deriveAccountId2(tokens.accessToken);
|
|
633
|
+
if (!accountId) {
|
|
634
|
+
throw new CodexAuthError(
|
|
635
|
+
"missing-account-id",
|
|
636
|
+
"The ChatGPT connection has no account identifier. Connect the account again."
|
|
637
|
+
);
|
|
638
|
+
}
|
|
639
|
+
return { accessToken: tokens.accessToken, accountId };
|
|
640
|
+
}
|
|
641
|
+
async function refreshTokens(current) {
|
|
642
|
+
const config = resolveConfig2({
|
|
643
|
+
fetch: (input, init) => globalThis.fetch(input, {
|
|
644
|
+
...init,
|
|
645
|
+
signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
|
|
646
|
+
})
|
|
647
|
+
});
|
|
648
|
+
try {
|
|
649
|
+
return {
|
|
650
|
+
status: "refreshed",
|
|
651
|
+
tokens: await ensureFreshTokens2(config, current, { force: true })
|
|
652
|
+
};
|
|
653
|
+
} catch (error) {
|
|
654
|
+
if (isRefreshTokenInvalid(error)) return { status: "revoked" };
|
|
655
|
+
throw new CodexAuthError(
|
|
656
|
+
"refresh-failed",
|
|
657
|
+
"Could not refresh the ChatGPT connection. Retry the request."
|
|
658
|
+
);
|
|
659
|
+
}
|
|
660
|
+
}
|
|
661
|
+
function messageOf(error, fallback) {
|
|
662
|
+
return error instanceof Error ? error.message : fallback;
|
|
663
|
+
}
|
|
664
|
+
|
|
665
|
+
// packages/experimental/src/providers/codex/index.ts
|
|
666
|
+
function createCodex() {
|
|
667
|
+
return codexProvider(
|
|
668
|
+
(input, init) => createCodexFetch2({
|
|
669
|
+
config: resolveConfig3(),
|
|
670
|
+
getAuth: () => getLocalCodexAuth(requestSignal(input, init))
|
|
671
|
+
})(input, init)
|
|
672
|
+
);
|
|
673
|
+
}
|
|
353
674
|
var codex = createCodex();
|
|
354
675
|
export {
|
|
676
|
+
CodexAuthError,
|
|
355
677
|
codex,
|
|
356
|
-
createCodex
|
|
678
|
+
createCodex,
|
|
679
|
+
createCodexAccounts
|
|
357
680
|
};
|
|
358
681
|
//# sourceMappingURL=index.js.map
|