orchajs 0.24.0 → 0.25.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 +50 -3
- package/dist/amarsia/analytics.js +12 -0
- package/dist/amarsia/inference.d.ts +6 -0
- package/dist/amarsia/inference.js +337 -0
- package/dist/browser.js +5 -0
- package/dist/cli-agents-template.d.ts +1 -1
- package/dist/cli-agents-template.js +31 -7
- package/dist/compiler/build-project.js +57 -14
- package/dist/compiler/node-esm-banner.d.ts +2 -0
- package/dist/compiler/node-esm-banner.js +5 -0
- package/dist/orcha.js +5 -0
- package/dist/project-loader.js +4 -2
- package/dist/providers/types.d.ts +4 -0
- package/dist/react-native.js +5 -0
- package/dist/runtime/agent.js +103 -14
- package/dist/runtime/compiler-hook.d.ts +4 -0
- package/dist/runtime/compiler-hook.js +9 -0
- package/dist/runtime/create-orcha.d.ts +19 -0
- package/dist/runtime/create-orcha.js +109 -12
- package/dist/runtime/optional-features.d.ts +19 -0
- package/dist/runtime/optional-features.js +22 -0
- package/dist/runtime/platform-browser.js +16 -3
- package/dist/runtime/platform-node.js +16 -2
- package/dist/runtime/platform-react-native.js +16 -3
- package/dist/storage/browser-indexeddb.d.ts +3 -0
- package/dist/storage/browser-indexeddb.js +72 -8
- package/dist/storage/cloud-outbox.d.ts +30 -0
- package/dist/storage/cloud-outbox.js +628 -0
- package/dist/storage/cloud.d.ts +1 -0
- package/dist/storage/cloud.js +1 -0
- package/dist/storage/node-jsonl.d.ts +3 -0
- package/dist/storage/node-jsonl.js +273 -4
- package/dist/storage/node-sqlite.d.ts +3 -0
- package/dist/storage/node-sqlite.js +66 -17
- package/dist/storage/react-native-jsonl.d.ts +3 -0
- package/dist/storage/react-native-jsonl.js +223 -0
- package/dist/types.d.ts +21 -2
- package/dist-cjs/amarsia/analytics.js +12 -0
- package/dist-cjs/amarsia/inference.js +335 -0
- package/dist-cjs/browser.js +5 -0
- package/dist-cjs/cli-agents-template.js +31 -7
- package/dist-cjs/compiler/build-project.js +68 -4
- package/dist-cjs/compiler/node-esm-banner.js +32 -0
- package/dist-cjs/orcha.js +5 -0
- package/dist-cjs/project-loader.js +7 -5
- package/dist-cjs/react-native.js +5 -0
- package/dist-cjs/runtime/agent.js +137 -30
- package/dist-cjs/runtime/compiler-hook.js +11 -0
- package/dist-cjs/runtime/create-orcha.js +117 -12
- package/dist-cjs/runtime/optional-features.js +58 -0
- package/dist-cjs/runtime/platform-browser.js +16 -3
- package/dist-cjs/runtime/platform-node.js +16 -2
- package/dist-cjs/runtime/platform-react-native.js +18 -3
- package/dist-cjs/storage/browser-indexeddb.js +73 -8
- package/dist-cjs/storage/cloud-outbox.js +646 -0
- package/dist-cjs/storage/cloud.js +29 -0
- package/dist-cjs/storage/node-jsonl.js +246 -3
- package/dist-cjs/storage/node-sqlite.js +70 -19
- package/dist-cjs/storage/react-native-jsonl.js +207 -0
- package/package.json +1 -1
package/README.md
CHANGED
|
@@ -319,15 +319,41 @@ npm install quickjs-emscripten-core @jitl/quickjs-singlefile-cjs-release-sync
|
|
|
319
319
|
|
|
320
320
|
---
|
|
321
321
|
|
|
322
|
+
## Amarsia inference
|
|
323
|
+
|
|
324
|
+
Set `amarsia.inference: true` to route every model round through Amarsia:
|
|
325
|
+
|
|
326
|
+
```js
|
|
327
|
+
orcha.init({
|
|
328
|
+
amarsia: {
|
|
329
|
+
key: process.env.AMARSIA_PROJECT_KEY,
|
|
330
|
+
inference: true,
|
|
331
|
+
// endpoint: "https://api.amarsia.com",
|
|
332
|
+
},
|
|
333
|
+
agents: {
|
|
334
|
+
coordinator: "./coordinator",
|
|
335
|
+
},
|
|
336
|
+
});
|
|
337
|
+
```
|
|
338
|
+
|
|
339
|
+
The provider and model remain in each agent or evaluation `index.json`.
|
|
340
|
+
Amarsia inference supports `openai`, `anthropic`, `googlegenai`, and
|
|
341
|
+
`deepseek`. Infrastructure-specific `bedrock` and `vertexai` providers remain
|
|
342
|
+
available only for direct inference. Inference uses
|
|
343
|
+
`POST /v3/model/v1/responses`, requires no local provider keys, and covers
|
|
344
|
+
normal runs, streaming, tool loops, MCP, subagents, tests, evaluations, replay,
|
|
345
|
+
structured output, and abort signals. Amarsia uses the workspace owner's
|
|
346
|
+
configured BYOK provider key first and falls back to managed credit billing.
|
|
347
|
+
When `inference` is absent or false, direct-provider behavior is unchanged.
|
|
348
|
+
|
|
349
|
+
---
|
|
350
|
+
|
|
322
351
|
## MCP connections
|
|
323
352
|
|
|
324
353
|
Assign named MCP connections directly to agents and subagents:
|
|
325
354
|
|
|
326
355
|
```js
|
|
327
356
|
orcha.init({
|
|
328
|
-
providers: {
|
|
329
|
-
anthropic: process.env.ANTHROPIC_API_KEY,
|
|
330
|
-
},
|
|
331
357
|
mcp: {
|
|
332
358
|
credentials: {
|
|
333
359
|
GITHUB_MCP_TOKEN: process.env.GITHUB_MCP_TOKEN,
|
|
@@ -454,6 +480,27 @@ JSONL by default at
|
|
|
454
480
|
shared `.orcha/sessions/orcha-sqlite.db` store, set
|
|
455
481
|
`storage: { strategy: "sqlite" }` in `orcha.init()` and install
|
|
456
482
|
`better-sqlite3`.
|
|
483
|
+
Use `storage: { strategy: "cloud" }` with `amarsia.key` for local-first cloud
|
|
484
|
+
storage. Node.js keeps JSONL locally, browsers use IndexedDB, and React
|
|
485
|
+
Native/Expo use AsyncStorage. Existing `list`, `get`, `history`, `events`, and
|
|
486
|
+
`resume` calls remain unchanged. Every append commits locally first and returns
|
|
487
|
+
without waiting for cloud latency. Delivery continues in bounded background
|
|
488
|
+
batches and is recovered from the durable local acknowledgement after restart.
|
|
489
|
+
Warm local reads return immediately and safely refresh an already-synchronized
|
|
490
|
+
tail in the background; unsent local tails are never overwritten. Permanent
|
|
491
|
+
delivery failures are parked to avoid retry loops and are retried by a new
|
|
492
|
+
append or an explicit `orcha.flushCloudStorage()`.
|
|
493
|
+
|
|
494
|
+
`flushCloudStorage({ timeoutMs })` resolves only when every outbox is empty and
|
|
495
|
+
throws if data remains pending. `orcha.close({ timeoutMs })` flushes, aborts and
|
|
496
|
+
joins in-flight cloud requests, and likewise throws on an incomplete flush.
|
|
497
|
+
Close establishes a storage lifecycle barrier: appends already writing locally
|
|
498
|
+
are included in the final outbox scan, while later appends are rejected.
|
|
499
|
+
Local events remain durable in either case. JSONL-backed cloud stores maintain
|
|
500
|
+
recoverable tail indexes so bounded delivery batches do not repeatedly parse
|
|
501
|
+
the full session history. Immutable-prefix conflicts preserve both sides and
|
|
502
|
+
surface as `storage_error`. Call and await `orcha.close()` before calling
|
|
503
|
+
synchronous `orcha.init()` again; overlapping initialized runtimes are rejected.
|
|
457
504
|
Client-action pause/resume, compiled local actions, and cumulative output
|
|
458
505
|
streaming are supported.
|
|
459
506
|
`run()` always starts a new session; `resume()` continues one with either a new
|
|
@@ -195,8 +195,20 @@ export function withAmarsiaTelemetry(options) {
|
|
|
195
195
|
const projections = new Map();
|
|
196
196
|
const pending = new Map();
|
|
197
197
|
return {
|
|
198
|
+
get cloudStoragePendingCount() {
|
|
199
|
+
return store.cloudStoragePendingCount;
|
|
200
|
+
},
|
|
201
|
+
get cloudStorageLastError() {
|
|
202
|
+
return store.cloudStorageLastError;
|
|
203
|
+
},
|
|
198
204
|
read: (sessionId) => store.read(sessionId),
|
|
205
|
+
readAfterSequence: store.readAfterSequence?.bind(store),
|
|
199
206
|
listSessionIds: () => store.listSessionIds(),
|
|
207
|
+
getCloudAcknowledgement: store.getCloudAcknowledgement?.bind(store),
|
|
208
|
+
setCloudAcknowledgement: store.setCloudAcknowledgement?.bind(store),
|
|
209
|
+
refreshCloudSession: store.refreshCloudSession?.bind(store),
|
|
210
|
+
flushCloudStorage: store.flushCloudStorage?.bind(store),
|
|
211
|
+
closeCloudStorage: store.closeCloudStorage?.bind(store),
|
|
200
212
|
describeLocation: store.describeLocation?.bind(store),
|
|
201
213
|
subscribe: store.subscribe?.bind(store),
|
|
202
214
|
subscribeAll: store.subscribeAll?.bind(store),
|
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
import type { ProviderResponseGenerator } from "../providers/types.js";
|
|
2
|
+
export interface AmarsiaInferenceConfiguration {
|
|
3
|
+
key: string;
|
|
4
|
+
endpoint?: string;
|
|
5
|
+
}
|
|
6
|
+
export declare function createAmarsiaInferenceGenerator(configuration: AmarsiaInferenceConfiguration): ProviderResponseGenerator;
|
|
@@ -0,0 +1,337 @@
|
|
|
1
|
+
import { OrchaError } from "../errors.js";
|
|
2
|
+
import { readLocalFileContent } from "../file-content.js";
|
|
3
|
+
import { readServerSentEvents } from "../providers/sse.js";
|
|
4
|
+
import { parseStructuredOutput } from "../runtime/structured-output.js";
|
|
5
|
+
import { resolveAmarsiaEndpoint } from "./endpoint.js";
|
|
6
|
+
const SUPPORTED_AMARSIA_PROVIDERS = new Set([
|
|
7
|
+
"openai",
|
|
8
|
+
"anthropic",
|
|
9
|
+
"googlegenai",
|
|
10
|
+
"vertexai",
|
|
11
|
+
"deepseek",
|
|
12
|
+
]);
|
|
13
|
+
export function createAmarsiaInferenceGenerator(configuration) {
|
|
14
|
+
const endpoint = resolveAmarsiaEndpoint(configuration.endpoint);
|
|
15
|
+
return (provider, _providerConfiguration, request) => generateThroughAmarsia(endpoint, configuration.key, provider, request);
|
|
16
|
+
}
|
|
17
|
+
async function generateThroughAmarsia(endpoint, key, provider, request) {
|
|
18
|
+
if (!key.trim()) {
|
|
19
|
+
throw new Error("Amarsia inference requires a non-empty amarsia.key.");
|
|
20
|
+
}
|
|
21
|
+
if (!SUPPORTED_AMARSIA_PROVIDERS.has(provider)) {
|
|
22
|
+
throw new OrchaError("unsupported_provider_capability", `Amarsia inference supports only OpenAI, Anthropic, Google GenAI, Vertex AI, and DeepSeek; received "${provider}".`);
|
|
23
|
+
}
|
|
24
|
+
if (request.outputType === "image" || request.outputType === "audio") {
|
|
25
|
+
throw new OrchaError("unsupported_provider_capability", `Amarsia Responses does not support "${request.outputType}" as a direct agent output.`);
|
|
26
|
+
}
|
|
27
|
+
const gatewayProvider = provider === "vertexai" ? "googlegenai" : provider;
|
|
28
|
+
const body = {
|
|
29
|
+
provider: gatewayProvider,
|
|
30
|
+
model: request.model,
|
|
31
|
+
instructions: request.systemPrompt,
|
|
32
|
+
input: await toResponsesInput(request.messages),
|
|
33
|
+
...(provider === "vertexai"
|
|
34
|
+
? { region: "global" }
|
|
35
|
+
: request.region && request.region !== "provider_managed"
|
|
36
|
+
? { region: request.region }
|
|
37
|
+
: {}),
|
|
38
|
+
...(request.maxTokens
|
|
39
|
+
? { max_output_tokens: request.maxTokens }
|
|
40
|
+
: {}),
|
|
41
|
+
...(request.publishOutput ? { stream: true } : {}),
|
|
42
|
+
};
|
|
43
|
+
if (request.tools.length > 0) {
|
|
44
|
+
body.tools = request.tools.map((tool) => ({
|
|
45
|
+
type: "function",
|
|
46
|
+
name: tool.name,
|
|
47
|
+
description: tool.description,
|
|
48
|
+
parameters: tool.parameters,
|
|
49
|
+
}));
|
|
50
|
+
}
|
|
51
|
+
if (request.outputType === "json") {
|
|
52
|
+
body.text = {
|
|
53
|
+
format: {
|
|
54
|
+
type: "json_schema",
|
|
55
|
+
name: "orcha_output",
|
|
56
|
+
schema: request.outputSchema ?? {},
|
|
57
|
+
strict: true,
|
|
58
|
+
},
|
|
59
|
+
};
|
|
60
|
+
}
|
|
61
|
+
body.reasoning = {
|
|
62
|
+
summary: "auto",
|
|
63
|
+
...(request.reasoningLevel ? { effort: request.reasoningLevel } : {}),
|
|
64
|
+
};
|
|
65
|
+
body.include = ["reasoning.encrypted_content"];
|
|
66
|
+
if (request.trace) {
|
|
67
|
+
body.metadata = {
|
|
68
|
+
agent_external_id: request.trace.agentExternalId,
|
|
69
|
+
session_id: request.trace.sessionId,
|
|
70
|
+
};
|
|
71
|
+
}
|
|
72
|
+
const response = await fetch(`${endpoint}/v3/model/v1/responses`, {
|
|
73
|
+
method: "POST",
|
|
74
|
+
headers: {
|
|
75
|
+
"content-type": "application/json",
|
|
76
|
+
authorization: `Bearer ${key}`,
|
|
77
|
+
},
|
|
78
|
+
body: JSON.stringify(body),
|
|
79
|
+
signal: request.signal,
|
|
80
|
+
});
|
|
81
|
+
if (!response.ok) {
|
|
82
|
+
const message = await responseError(response);
|
|
83
|
+
throw new Error(message ??
|
|
84
|
+
`Amarsia inference request failed with HTTP ${response.status}.`);
|
|
85
|
+
}
|
|
86
|
+
const responseBody = response.headers
|
|
87
|
+
.get("content-type")
|
|
88
|
+
?.includes("text/event-stream")
|
|
89
|
+
? await readGatewayStream(response, request.publishOutput)
|
|
90
|
+
: (await response.json());
|
|
91
|
+
return toProviderResponse(request, responseBody);
|
|
92
|
+
}
|
|
93
|
+
async function toResponsesInput(messages) {
|
|
94
|
+
const input = [];
|
|
95
|
+
for (const message of messages) {
|
|
96
|
+
if (message.role === "user") {
|
|
97
|
+
input.push({
|
|
98
|
+
role: "user",
|
|
99
|
+
content: typeof message.content === "string"
|
|
100
|
+
? message.content
|
|
101
|
+
: await Promise.all(message.content.map(toResponsesUserContent)),
|
|
102
|
+
});
|
|
103
|
+
continue;
|
|
104
|
+
}
|
|
105
|
+
if (message.role === "tool") {
|
|
106
|
+
for (const result of message.results) {
|
|
107
|
+
input.push({
|
|
108
|
+
type: "function_call_output",
|
|
109
|
+
call_id: result.callId,
|
|
110
|
+
output: JSON.stringify(result.output ?? null),
|
|
111
|
+
...(result.isError ? { is_error: true } : {}),
|
|
112
|
+
});
|
|
113
|
+
}
|
|
114
|
+
continue;
|
|
115
|
+
}
|
|
116
|
+
for (const block of message.content) {
|
|
117
|
+
if (block.type === "text") {
|
|
118
|
+
input.push({
|
|
119
|
+
role: "assistant",
|
|
120
|
+
content: [{ type: "output_text", text: block.text }],
|
|
121
|
+
});
|
|
122
|
+
}
|
|
123
|
+
else if (block.type === "tool_call") {
|
|
124
|
+
input.push({
|
|
125
|
+
type: "function_call",
|
|
126
|
+
call_id: block.callId,
|
|
127
|
+
name: block.name,
|
|
128
|
+
arguments: JSON.stringify(block.arguments),
|
|
129
|
+
...(block.replay?.providerId
|
|
130
|
+
? { id: block.replay.providerId }
|
|
131
|
+
: {}),
|
|
132
|
+
...(block.replay?.opaqueData
|
|
133
|
+
? { encrypted_content: block.replay.opaqueData }
|
|
134
|
+
: {}),
|
|
135
|
+
});
|
|
136
|
+
}
|
|
137
|
+
else {
|
|
138
|
+
input.push({
|
|
139
|
+
type: "reasoning",
|
|
140
|
+
...(block.replay?.providerId
|
|
141
|
+
? { id: block.replay.providerId }
|
|
142
|
+
: {}),
|
|
143
|
+
summary: block.text
|
|
144
|
+
? [{ type: "summary_text", text: block.text }]
|
|
145
|
+
: [],
|
|
146
|
+
...(block.replay?.opaqueData
|
|
147
|
+
? { encrypted_content: block.replay.opaqueData }
|
|
148
|
+
: {}),
|
|
149
|
+
});
|
|
150
|
+
}
|
|
151
|
+
}
|
|
152
|
+
}
|
|
153
|
+
return input;
|
|
154
|
+
}
|
|
155
|
+
async function toResponsesUserContent(content) {
|
|
156
|
+
if (content.type === "text") {
|
|
157
|
+
return { type: "input_text", text: content.text };
|
|
158
|
+
}
|
|
159
|
+
if (content.type === "file") {
|
|
160
|
+
const file = await readLocalFileContent(content);
|
|
161
|
+
return content.mimeType.startsWith("image/")
|
|
162
|
+
? {
|
|
163
|
+
type: "input_image",
|
|
164
|
+
image_url: file.dataUri,
|
|
165
|
+
detail: "auto",
|
|
166
|
+
}
|
|
167
|
+
: {
|
|
168
|
+
type: "input_file",
|
|
169
|
+
file_data: file.dataUri,
|
|
170
|
+
filename: file.fileName,
|
|
171
|
+
};
|
|
172
|
+
}
|
|
173
|
+
if (content.type === "image") {
|
|
174
|
+
return {
|
|
175
|
+
type: "input_image",
|
|
176
|
+
image_url: content.fileUri,
|
|
177
|
+
detail: "auto",
|
|
178
|
+
};
|
|
179
|
+
}
|
|
180
|
+
if (content.type === "url") {
|
|
181
|
+
return { type: "input_file", file_url: content.fileUri };
|
|
182
|
+
}
|
|
183
|
+
throw new OrchaError("unsupported_content_type", `Amarsia Responses does not support ${content.type} content from a URI.`);
|
|
184
|
+
}
|
|
185
|
+
async function readGatewayStream(response, publishOutput) {
|
|
186
|
+
let text = "";
|
|
187
|
+
let terminal;
|
|
188
|
+
for await (const event of readServerSentEvents(response)) {
|
|
189
|
+
if (event.type === "response.output_text.delta" &&
|
|
190
|
+
typeof event.delta === "string") {
|
|
191
|
+
text += event.delta;
|
|
192
|
+
publishOutput?.(text);
|
|
193
|
+
}
|
|
194
|
+
else if (event.type === "response.completed" ||
|
|
195
|
+
event.type === "response.incomplete") {
|
|
196
|
+
if (!isRecord(event.response)) {
|
|
197
|
+
throw new Error("Amarsia returned an invalid terminal stream event.");
|
|
198
|
+
}
|
|
199
|
+
terminal = event.response;
|
|
200
|
+
}
|
|
201
|
+
else if (event.type === "response.failed" ||
|
|
202
|
+
event.type === "error") {
|
|
203
|
+
const error = isRecord(event.error) ? event.error : event;
|
|
204
|
+
throw new Error(typeof error.message === "string"
|
|
205
|
+
? error.message
|
|
206
|
+
: "Amarsia inference streaming request failed.");
|
|
207
|
+
}
|
|
208
|
+
}
|
|
209
|
+
if (!terminal) {
|
|
210
|
+
throw new Error("Amarsia inference stream ended without a terminal response.");
|
|
211
|
+
}
|
|
212
|
+
return terminal;
|
|
213
|
+
}
|
|
214
|
+
function toProviderResponse(request, response) {
|
|
215
|
+
if (response.status === "failed") {
|
|
216
|
+
throw new Error(response.error?.message ?? "Amarsia failed to generate a response.");
|
|
217
|
+
}
|
|
218
|
+
if (response.status === "incomplete" &&
|
|
219
|
+
response.incomplete_details?.reason !== "max_output_tokens") {
|
|
220
|
+
throw new Error(`Amarsia returned an incomplete response: ${response.incomplete_details?.reason ?? "unknown reason"}.`);
|
|
221
|
+
}
|
|
222
|
+
const content = [];
|
|
223
|
+
let refused = false;
|
|
224
|
+
for (const item of response.output ?? []) {
|
|
225
|
+
if (item.type === "message") {
|
|
226
|
+
for (const part of item.content ?? []) {
|
|
227
|
+
if (part.type === "output_text" &&
|
|
228
|
+
typeof part.text === "string") {
|
|
229
|
+
content.push({ type: "text", text: part.text });
|
|
230
|
+
}
|
|
231
|
+
else if (part.type === "refusal" &&
|
|
232
|
+
typeof part.refusal === "string") {
|
|
233
|
+
refused = true;
|
|
234
|
+
content.push({ type: "text", text: part.refusal });
|
|
235
|
+
}
|
|
236
|
+
}
|
|
237
|
+
}
|
|
238
|
+
else if (item.type === "function_call" &&
|
|
239
|
+
typeof item.call_id === "string" &&
|
|
240
|
+
typeof item.name === "string") {
|
|
241
|
+
content.push({
|
|
242
|
+
type: "tool_call",
|
|
243
|
+
callId: item.call_id,
|
|
244
|
+
name: item.name,
|
|
245
|
+
arguments: parseArguments(item.arguments, item.name),
|
|
246
|
+
replay: replay(item),
|
|
247
|
+
});
|
|
248
|
+
}
|
|
249
|
+
else if (item.type === "reasoning") {
|
|
250
|
+
content.push({
|
|
251
|
+
type: "reasoning",
|
|
252
|
+
text: [...(item.content ?? []), ...(item.summary ?? [])]
|
|
253
|
+
.filter((part) => (part.type === "reasoning_text" ||
|
|
254
|
+
part.type === "summary_text") &&
|
|
255
|
+
typeof part.text === "string")
|
|
256
|
+
.map((part) => part.text)
|
|
257
|
+
.join(""),
|
|
258
|
+
replay: replay(item),
|
|
259
|
+
});
|
|
260
|
+
}
|
|
261
|
+
else {
|
|
262
|
+
throw new Error(`Amarsia returned unsupported output item "${String(item.type)}".`);
|
|
263
|
+
}
|
|
264
|
+
}
|
|
265
|
+
const toolCalls = content.filter((block) => block.type === "tool_call");
|
|
266
|
+
const textOutput = response.output_text ??
|
|
267
|
+
content
|
|
268
|
+
.filter((block) => block.type === "text")
|
|
269
|
+
.map((block) => block.text)
|
|
270
|
+
.join("");
|
|
271
|
+
const stopReason = normalizeStopReason(response, toolCalls, refused);
|
|
272
|
+
const output = request.outputType === "json" &&
|
|
273
|
+
toolCalls.length === 0 &&
|
|
274
|
+
stopReason !== "max_tokens"
|
|
275
|
+
? parseStructuredOutput(textOutput, request.outputSchema ?? {})
|
|
276
|
+
: textOutput;
|
|
277
|
+
if (textOutput) {
|
|
278
|
+
request.publishOutput?.(textOutput);
|
|
279
|
+
}
|
|
280
|
+
return {
|
|
281
|
+
output,
|
|
282
|
+
responseId: response.id,
|
|
283
|
+
stopReason,
|
|
284
|
+
content,
|
|
285
|
+
toolCalls,
|
|
286
|
+
usage: normalizeUsage(response.usage),
|
|
287
|
+
};
|
|
288
|
+
}
|
|
289
|
+
function replay(item) {
|
|
290
|
+
const value = {
|
|
291
|
+
...(typeof item.id === "string" ? { providerId: item.id } : {}),
|
|
292
|
+
...(typeof item.encrypted_content === "string"
|
|
293
|
+
? { opaqueData: item.encrypted_content }
|
|
294
|
+
: {}),
|
|
295
|
+
};
|
|
296
|
+
return Object.keys(value).length > 0 ? value : undefined;
|
|
297
|
+
}
|
|
298
|
+
function parseArguments(value, name) {
|
|
299
|
+
const parsed = typeof value === "string" ? JSON.parse(value) : value;
|
|
300
|
+
if (!isRecord(parsed)) {
|
|
301
|
+
throw new Error(`Amarsia returned non-object arguments for tool "${name}".`);
|
|
302
|
+
}
|
|
303
|
+
return parsed;
|
|
304
|
+
}
|
|
305
|
+
function normalizeStopReason(response, toolCalls, refused) {
|
|
306
|
+
if (refused)
|
|
307
|
+
return "content_filter";
|
|
308
|
+
if (toolCalls.length > 0)
|
|
309
|
+
return "tool_call";
|
|
310
|
+
if (response.status === "incomplete") {
|
|
311
|
+
return response.incomplete_details?.reason === "max_output_tokens"
|
|
312
|
+
? "max_tokens"
|
|
313
|
+
: "unknown";
|
|
314
|
+
}
|
|
315
|
+
return response.status === "completed" ? "end_turn" : "unknown";
|
|
316
|
+
}
|
|
317
|
+
function normalizeUsage(usage) {
|
|
318
|
+
return {
|
|
319
|
+
inputTokens: usage?.input_tokens ?? 0,
|
|
320
|
+
outputTokens: usage?.output_tokens ?? 0,
|
|
321
|
+
reasoningTokens: usage?.output_tokens_details?.reasoning_tokens ?? null,
|
|
322
|
+
cacheReadTokens: usage?.input_tokens_details?.cached_tokens ?? 0,
|
|
323
|
+
cacheWriteTokens: usage?.cache_write_tokens ?? 0,
|
|
324
|
+
};
|
|
325
|
+
}
|
|
326
|
+
async function responseError(response) {
|
|
327
|
+
try {
|
|
328
|
+
const body = (await response.json());
|
|
329
|
+
return body.error?.message ?? body.message;
|
|
330
|
+
}
|
|
331
|
+
catch {
|
|
332
|
+
return undefined;
|
|
333
|
+
}
|
|
334
|
+
}
|
|
335
|
+
function isRecord(value) {
|
|
336
|
+
return typeof value === "object" && value !== null && !Array.isArray(value);
|
|
337
|
+
}
|
package/dist/browser.js
CHANGED
|
@@ -1,11 +1,16 @@
|
|
|
1
|
+
import { createAmarsiaInferenceGenerator } from "./amarsia/inference.js";
|
|
1
2
|
import { generateBrowserProviderResponse } from "./providers/browser.js";
|
|
2
3
|
import { setNativeRuntimeLoader } from "./runtime/actions/execute.js";
|
|
3
4
|
import { createOrcha } from "./runtime/create-orcha.js";
|
|
5
|
+
import { setCloudSessionStoreFactory, setInferenceGeneratorFactory, } from "./runtime/optional-features.js";
|
|
4
6
|
import { browserRuntimePlatform } from "./runtime/platform-browser.js";
|
|
7
|
+
import { CloudSessionStore } from "./storage/cloud.js";
|
|
5
8
|
setNativeRuntimeLoader(async () => {
|
|
6
9
|
const modulePath = "./runtime/actions/browser-native.js";
|
|
7
10
|
return import(modulePath);
|
|
8
11
|
});
|
|
12
|
+
setInferenceGeneratorFactory(createAmarsiaInferenceGenerator);
|
|
13
|
+
setCloudSessionStoreFactory((options) => new CloudSessionStore(options));
|
|
9
14
|
export const orcha = createOrcha(() => {
|
|
10
15
|
throw new Error("The browser runtime requires a precompiled Orcha bundle. Configure the Orcha integration for your application bundler.");
|
|
11
16
|
}, generateBrowserProviderResponse, browserRuntimePlatform);
|