@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,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
|
|
@@ -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
|
|
194
|
-
|
|
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
|
-
}
|
|
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/
|
|
327
|
-
|
|
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-
|
|
332
|
-
fetch
|
|
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
|