@deepagents/experimental 6.1.0 → 6.1.2
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/dist/index.js +441 -19
- package/dist/index.js.map +4 -4
- package/dist/zukhruf/control-plane/agent-declaration-registry.d.ts +1 -0
- package/dist/zukhruf/control-plane/agent-declaration-registry.d.ts.map +1 -1
- package/dist/zukhruf/index.d.ts +1 -0
- package/dist/zukhruf/index.d.ts.map +1 -1
- package/dist/zukhruf/index.js +441 -19
- package/dist/zukhruf/index.js.map +4 -4
- package/dist/zukhruf/protocol/parse.d.ts +3 -0
- package/dist/zukhruf/protocol/parse.d.ts.map +1 -0
- package/dist/zukhruf/protocol/session.d.ts +23 -0
- package/dist/zukhruf/protocol/session.d.ts.map +1 -0
- package/dist/zukhruf/protocol/validator.d.ts +64 -0
- package/dist/zukhruf/protocol/validator.d.ts.map +1 -0
- package/dist/zukhruf/runtime/agent-runtime.d.ts +15 -0
- package/dist/zukhruf/runtime/agent-runtime.d.ts.map +1 -1
- package/package.json +4 -2
package/dist/index.js
CHANGED
|
@@ -330,13 +330,22 @@ __export(zukhruf_exports, {
|
|
|
330
330
|
PgBossTurnQueue: () => PgBossTurnQueue,
|
|
331
331
|
SqliteMailboxStore: () => SqliteMailboxStore,
|
|
332
332
|
TurnQueue: () => TurnQueue,
|
|
333
|
+
ZUKHRUF_CREATE_SESSION_ROUTE_PATH: () => ZUKHRUF_CREATE_SESSION_ROUTE_PATH,
|
|
334
|
+
ZUKHRUF_HEALTH_ROUTE_PATH: () => ZUKHRUF_HEALTH_ROUTE_PATH,
|
|
335
|
+
ZUKHRUF_INFO_ROUTE_PATH: () => ZUKHRUF_INFO_ROUTE_PATH,
|
|
336
|
+
ZUKHRUF_ROUTE_PREFIX: () => ZUKHRUF_ROUTE_PREFIX,
|
|
337
|
+
ZUKHRUF_SESSION_CANCEL_ROUTE_PATH: () => ZUKHRUF_SESSION_CANCEL_ROUTE_PATH,
|
|
338
|
+
ZUKHRUF_SESSION_ID_HEADER: () => ZUKHRUF_SESSION_ID_HEADER,
|
|
339
|
+
ZUKHRUF_SESSION_ROUTE_PATH: () => ZUKHRUF_SESSION_ROUTE_PATH,
|
|
340
|
+
ZUKHRUF_SESSION_STREAM_ROUTE_PATH: () => ZUKHRUF_SESSION_STREAM_ROUTE_PATH,
|
|
333
341
|
assertCommunication: () => assertCommunication,
|
|
334
342
|
createInterAgentCommunication: () => createInterAgentCommunication,
|
|
335
343
|
defineAgent: () => defineAgent,
|
|
336
344
|
defineInstructions: () => defineInstructions,
|
|
337
345
|
defineSandbox: () => defineSandbox,
|
|
338
346
|
defineTool: () => defineTool,
|
|
339
|
-
renderTurn: () => renderTurn
|
|
347
|
+
renderTurn: () => renderTurn,
|
|
348
|
+
zukhruf: () => zukhruf
|
|
340
349
|
});
|
|
341
350
|
|
|
342
351
|
// packages/experimental/src/zukhruf/agent.ts
|
|
@@ -436,11 +445,11 @@ var AgentThread = class _AgentThread {
|
|
|
436
445
|
}
|
|
437
446
|
static fromMetadata(conversation, metadata) {
|
|
438
447
|
const treeId = metadata?.zukhrufTreeId;
|
|
439
|
-
const
|
|
440
|
-
if (typeof treeId !== "string" || !_AgentThread.#isRecord(
|
|
448
|
+
const zukhruf2 = metadata?.zukhruf;
|
|
449
|
+
if (typeof treeId !== "string" || !_AgentThread.#isRecord(zukhruf2)) {
|
|
441
450
|
return void 0;
|
|
442
451
|
}
|
|
443
|
-
const { path: path2, parentChatId, declarationName, lastTurnId } =
|
|
452
|
+
const { path: path2, parentChatId, declarationName, lastTurnId } = zukhruf2;
|
|
444
453
|
if (typeof path2 !== "string" || parentChatId !== null && typeof parentChatId !== "string" || typeof declarationName !== "string" || lastTurnId !== void 0 && typeof lastTurnId !== "string") {
|
|
445
454
|
return void 0;
|
|
446
455
|
}
|
|
@@ -575,6 +584,9 @@ var AgentDeclarationRegistry = class {
|
|
|
575
584
|
get(name) {
|
|
576
585
|
return this.#declarations.get(name);
|
|
577
586
|
}
|
|
587
|
+
values() {
|
|
588
|
+
return this.#declarations.values();
|
|
589
|
+
}
|
|
578
590
|
#register(declaration, visited) {
|
|
579
591
|
if (visited.has(declaration)) return;
|
|
580
592
|
visited.add(declaration);
|
|
@@ -859,14 +871,14 @@ var AgentHistoryForker = class {
|
|
|
859
871
|
let claimed;
|
|
860
872
|
await this.#store.updateChat(child.conversation.chatId, (chat2) => {
|
|
861
873
|
const metadata = chat2.metadata;
|
|
862
|
-
const
|
|
863
|
-
if (!isRecord(
|
|
874
|
+
const zukhruf2 = metadata?.zukhruf;
|
|
875
|
+
if (!isRecord(zukhruf2)) {
|
|
864
876
|
throw new Error(
|
|
865
877
|
`spawn_agent: child chat "${child.conversation.chatId}" is missing Zukhruf metadata`
|
|
866
878
|
);
|
|
867
879
|
}
|
|
868
|
-
if (
|
|
869
|
-
claimed = parseHistoryForkRecord(
|
|
880
|
+
if (zukhruf2.historyFork !== void 0) {
|
|
881
|
+
claimed = parseHistoryForkRecord(zukhruf2.historyFork);
|
|
870
882
|
if (claimed.parentChatId !== proposed.parentChatId || claimed.forkTurns !== proposed.forkTurns) {
|
|
871
883
|
throw new Error(
|
|
872
884
|
`spawn_agent: agent path "${child.path}" already exists with a different fork_turns setting`
|
|
@@ -878,7 +890,7 @@ var AgentHistoryForker = class {
|
|
|
878
890
|
return {
|
|
879
891
|
metadata: {
|
|
880
892
|
...metadata,
|
|
881
|
-
zukhruf: { ...
|
|
893
|
+
zukhruf: { ...zukhruf2, historyFork: proposed }
|
|
882
894
|
}
|
|
883
895
|
};
|
|
884
896
|
});
|
|
@@ -965,13 +977,13 @@ var AgentHistoryForker = class {
|
|
|
965
977
|
let sourceMessageIds;
|
|
966
978
|
await this.#store.updateChat(child.conversation.chatId, (chat2) => {
|
|
967
979
|
const metadata = chat2.metadata;
|
|
968
|
-
const
|
|
969
|
-
if (!isRecord(
|
|
980
|
+
const zukhruf2 = metadata?.zukhruf;
|
|
981
|
+
if (!isRecord(zukhruf2)) {
|
|
970
982
|
throw new Error(
|
|
971
983
|
`spawn_agent: child chat "${child.conversation.chatId}" is missing Zukhruf metadata`
|
|
972
984
|
);
|
|
973
985
|
}
|
|
974
|
-
const record = parseHistoryForkRecord(
|
|
986
|
+
const record = parseHistoryForkRecord(zukhruf2.historyFork);
|
|
975
987
|
if (record.sourceMessageIds !== void 0) {
|
|
976
988
|
sourceMessageIds = record.sourceMessageIds;
|
|
977
989
|
return void 0;
|
|
@@ -981,7 +993,7 @@ var AgentHistoryForker = class {
|
|
|
981
993
|
metadata: {
|
|
982
994
|
...metadata,
|
|
983
995
|
zukhruf: {
|
|
984
|
-
...
|
|
996
|
+
...zukhruf2,
|
|
985
997
|
historyFork: { ...record, sourceMessageIds: proposedIds }
|
|
986
998
|
}
|
|
987
999
|
}
|
|
@@ -2125,11 +2137,11 @@ var AgentTurnExecutor = class {
|
|
|
2125
2137
|
available = persisted;
|
|
2126
2138
|
return void 0;
|
|
2127
2139
|
}
|
|
2128
|
-
const
|
|
2140
|
+
const zukhruf2 = isRecord2(metadata?.zukhruf) ? metadata.zukhruf : {};
|
|
2129
2141
|
return {
|
|
2130
2142
|
metadata: {
|
|
2131
2143
|
...metadata,
|
|
2132
|
-
zukhruf: { ...
|
|
2144
|
+
zukhruf: { ...zukhruf2, skills: available }
|
|
2133
2145
|
}
|
|
2134
2146
|
};
|
|
2135
2147
|
});
|
|
@@ -2164,14 +2176,14 @@ ${communication.content}`;
|
|
|
2164
2176
|
}
|
|
2165
2177
|
};
|
|
2166
2178
|
function readSkills(metadata) {
|
|
2167
|
-
const
|
|
2168
|
-
if (!isRecord2(
|
|
2179
|
+
const zukhruf2 = metadata?.zukhruf;
|
|
2180
|
+
if (!isRecord2(zukhruf2) || !Object.hasOwn(zukhruf2, "skills")) {
|
|
2169
2181
|
return void 0;
|
|
2170
2182
|
}
|
|
2171
|
-
if (!Array.isArray(
|
|
2183
|
+
if (!Array.isArray(zukhruf2.skills) || !zukhruf2.skills.every(isSkill)) {
|
|
2172
2184
|
throw new Error("AgentRuntime: stored skill catalog is invalid");
|
|
2173
2185
|
}
|
|
2174
|
-
return
|
|
2186
|
+
return zukhruf2.skills;
|
|
2175
2187
|
}
|
|
2176
2188
|
function isSkill(value) {
|
|
2177
2189
|
return isRecord2(value) && typeof value.name === "string" && typeof value.description === "string" && typeof value.path === "string";
|
|
@@ -2460,11 +2472,21 @@ var AgentObservation = class {
|
|
|
2460
2472
|
}
|
|
2461
2473
|
}
|
|
2462
2474
|
async #headStreamId() {
|
|
2475
|
+
const scheduled = await this.#queue.getCurrentTurn(this.#conversation);
|
|
2476
|
+
if (scheduled) return scheduled.streamId;
|
|
2477
|
+
const chat2 = await this.#store.getChat(this.#conversation.chatId);
|
|
2478
|
+
if (!chat2) return void 0;
|
|
2479
|
+
if (chat2.userId !== this.#conversation.userId) {
|
|
2480
|
+
throw new Error(
|
|
2481
|
+
`chat "${this.#conversation.chatId}" belongs to user "${chat2.userId}", not "${this.#conversation.userId}"`
|
|
2482
|
+
);
|
|
2483
|
+
}
|
|
2463
2484
|
const head = await this.engine.headMessage();
|
|
2464
2485
|
return head?.name === "assistant" ? head.id : void 0;
|
|
2465
2486
|
}
|
|
2466
2487
|
};
|
|
2467
2488
|
var AgentRuntime = class {
|
|
2489
|
+
info;
|
|
2468
2490
|
#store;
|
|
2469
2491
|
#queue;
|
|
2470
2492
|
#streams;
|
|
@@ -2513,6 +2535,18 @@ var AgentRuntime = class {
|
|
|
2513
2535
|
this.#directory = directory;
|
|
2514
2536
|
this.#controlPlane = controlPlane;
|
|
2515
2537
|
this.#approvals = approvals;
|
|
2538
|
+
this.info = {
|
|
2539
|
+
root: declarations.root.name,
|
|
2540
|
+
agents: Array.from(declarations.values(), (declaration) => ({
|
|
2541
|
+
name: declaration.name,
|
|
2542
|
+
model: {
|
|
2543
|
+
provider: declaration.model.provider,
|
|
2544
|
+
modelId: declaration.model.modelId
|
|
2545
|
+
},
|
|
2546
|
+
tools: Object.keys(declaration.tools ?? {}).sort(),
|
|
2547
|
+
subagents: (declaration.subagents ?? []).map(({ name }) => name)
|
|
2548
|
+
}))
|
|
2549
|
+
};
|
|
2516
2550
|
this.#executor = new AgentTurnExecutor({
|
|
2517
2551
|
store: options.store,
|
|
2518
2552
|
streams,
|
|
@@ -2522,6 +2556,14 @@ var AgentRuntime = class {
|
|
|
2522
2556
|
multiAgentV2
|
|
2523
2557
|
});
|
|
2524
2558
|
}
|
|
2559
|
+
async createSession(conversation) {
|
|
2560
|
+
await this.#controlPlane.resolve(conversation);
|
|
2561
|
+
}
|
|
2562
|
+
async sessionExists(conversation) {
|
|
2563
|
+
const chat2 = await this.#store.getChat(conversation.chatId);
|
|
2564
|
+
if (!chat2 || chat2.userId !== conversation.userId) return false;
|
|
2565
|
+
return (await this.#directory.load(conversation))?.path.isRoot ?? false;
|
|
2566
|
+
}
|
|
2525
2567
|
async enqueue(conversation, turn) {
|
|
2526
2568
|
const streamId = await this.#controlPlane.enqueue(conversation, turn);
|
|
2527
2569
|
return { id: streamId, stream: this.#streams.watch(streamId) };
|
|
@@ -2813,6 +2855,386 @@ var SqliteMailboxStore = class extends MailboxStore {
|
|
|
2813
2855
|
}
|
|
2814
2856
|
};
|
|
2815
2857
|
|
|
2858
|
+
// packages/experimental/src/zukhruf/protocol/session.ts
|
|
2859
|
+
import { createUIMessageStreamResponse } from "ai";
|
|
2860
|
+
import { Hono } from "hono";
|
|
2861
|
+
import { bodyLimit } from "hono/body-limit";
|
|
2862
|
+
import { HTTPException as HTTPException3 } from "hono/http-exception";
|
|
2863
|
+
import { v5 as uuidv56, validate as validateUuid } from "uuid";
|
|
2864
|
+
import z9 from "zod";
|
|
2865
|
+
|
|
2866
|
+
// packages/experimental/src/zukhruf/protocol/validator.ts
|
|
2867
|
+
import { parse as parseContentType } from "fast-content-type-parse";
|
|
2868
|
+
import { createMiddleware } from "hono/factory";
|
|
2869
|
+
import { HTTPException as HTTPException2 } from "hono/http-exception";
|
|
2870
|
+
import z8 from "zod";
|
|
2871
|
+
|
|
2872
|
+
// packages/experimental/src/zukhruf/protocol/parse.ts
|
|
2873
|
+
import { HTTPException } from "hono/http-exception";
|
|
2874
|
+
import "zod";
|
|
2875
|
+
async function parse(schema, input) {
|
|
2876
|
+
const result = await schema.safeParseAsync(input);
|
|
2877
|
+
if (!result.success) {
|
|
2878
|
+
const errors = result.error.flatten((issue) => ({
|
|
2879
|
+
message: issue.message,
|
|
2880
|
+
code: issue.code,
|
|
2881
|
+
path: issue.path.join(".")
|
|
2882
|
+
})).fieldErrors;
|
|
2883
|
+
throw new HTTPException(400, {
|
|
2884
|
+
message: "Validation failed",
|
|
2885
|
+
cause: {
|
|
2886
|
+
code: "api/validation-failed",
|
|
2887
|
+
detail: "The input data is invalid",
|
|
2888
|
+
errors
|
|
2889
|
+
}
|
|
2890
|
+
});
|
|
2891
|
+
}
|
|
2892
|
+
return result.data;
|
|
2893
|
+
}
|
|
2894
|
+
|
|
2895
|
+
// packages/experimental/src/zukhruf/protocol/validator.ts
|
|
2896
|
+
function validate(expectedContentTypeOrSelector, selector) {
|
|
2897
|
+
const expectedContentType = typeof expectedContentTypeOrSelector === "string" ? expectedContentTypeOrSelector : void 0;
|
|
2898
|
+
const _selector = typeof expectedContentTypeOrSelector === "function" ? expectedContentTypeOrSelector : selector;
|
|
2899
|
+
if (!_selector) {
|
|
2900
|
+
throw new Error("Selector function is required");
|
|
2901
|
+
}
|
|
2902
|
+
return createMiddleware(async (c, next) => {
|
|
2903
|
+
const ct = c.req.header("content-type");
|
|
2904
|
+
if (c.req.method === "GET" && ct) {
|
|
2905
|
+
throw new HTTPException2(415, {
|
|
2906
|
+
message: "Unsupported Media Type",
|
|
2907
|
+
cause: {
|
|
2908
|
+
code: "api/unsupported-media-type",
|
|
2909
|
+
detail: `GET requests cannot have a content type header`
|
|
2910
|
+
}
|
|
2911
|
+
});
|
|
2912
|
+
}
|
|
2913
|
+
if (expectedContentType) {
|
|
2914
|
+
void verifyContentType(ct, expectedContentType);
|
|
2915
|
+
}
|
|
2916
|
+
const contentType = ct ? parseContentType(ct) : null;
|
|
2917
|
+
let body = null;
|
|
2918
|
+
switch (contentType?.type) {
|
|
2919
|
+
case "application/json":
|
|
2920
|
+
body = await parseJson(c);
|
|
2921
|
+
break;
|
|
2922
|
+
case "application/x-www-form-urlencoded":
|
|
2923
|
+
case "multipart/form-data":
|
|
2924
|
+
body = await c.req.parseBody();
|
|
2925
|
+
break;
|
|
2926
|
+
default:
|
|
2927
|
+
body = {};
|
|
2928
|
+
}
|
|
2929
|
+
const payload = {
|
|
2930
|
+
body,
|
|
2931
|
+
query: parseQueryParams(c.req.query()),
|
|
2932
|
+
queries: parseQueriesParams(c.req.queries()),
|
|
2933
|
+
params: c.req.param(),
|
|
2934
|
+
headers: Object.fromEntries(
|
|
2935
|
+
Object.entries(c.req.header()).map(([k, v]) => [k, v ?? ""])
|
|
2936
|
+
)
|
|
2937
|
+
};
|
|
2938
|
+
const config = _selector(payload);
|
|
2939
|
+
const schema = z8.object(
|
|
2940
|
+
Object.entries(config).reduce(
|
|
2941
|
+
(acc, [key, value]) => {
|
|
2942
|
+
acc[key] = value.against;
|
|
2943
|
+
return acc;
|
|
2944
|
+
},
|
|
2945
|
+
{}
|
|
2946
|
+
)
|
|
2947
|
+
);
|
|
2948
|
+
const input = Object.entries(config).reduce(
|
|
2949
|
+
(acc, [key, value]) => {
|
|
2950
|
+
acc[key] = value.select;
|
|
2951
|
+
return acc;
|
|
2952
|
+
},
|
|
2953
|
+
{}
|
|
2954
|
+
);
|
|
2955
|
+
const parsed = await parse(schema, input);
|
|
2956
|
+
c.set("input", parsed);
|
|
2957
|
+
await next();
|
|
2958
|
+
});
|
|
2959
|
+
}
|
|
2960
|
+
function verifyContentType(actual, expected) {
|
|
2961
|
+
if (!actual) {
|
|
2962
|
+
throw new HTTPException2(415, {
|
|
2963
|
+
message: "Unsupported Media Type",
|
|
2964
|
+
cause: {
|
|
2965
|
+
code: "api/unsupported-media-type",
|
|
2966
|
+
detail: "Missing content type header"
|
|
2967
|
+
}
|
|
2968
|
+
});
|
|
2969
|
+
}
|
|
2970
|
+
const { type: incomingContentType } = parseContentType(actual);
|
|
2971
|
+
if (incomingContentType !== expected) {
|
|
2972
|
+
throw new HTTPException2(415, {
|
|
2973
|
+
message: "Unsupported Media Type",
|
|
2974
|
+
cause: {
|
|
2975
|
+
code: "api/unsupported-media-type",
|
|
2976
|
+
detail: `Expected content type: ${expected}, but got: ${incomingContentType}`
|
|
2977
|
+
}
|
|
2978
|
+
});
|
|
2979
|
+
}
|
|
2980
|
+
}
|
|
2981
|
+
async function parseJson(context) {
|
|
2982
|
+
try {
|
|
2983
|
+
return await context.req.json();
|
|
2984
|
+
} catch (error) {
|
|
2985
|
+
throw new HTTPException2(400, {
|
|
2986
|
+
message: "The request body is not valid JSON",
|
|
2987
|
+
cause: {
|
|
2988
|
+
code: "api/invalid-json",
|
|
2989
|
+
detail: error instanceof Error ? error.message : String(error)
|
|
2990
|
+
}
|
|
2991
|
+
});
|
|
2992
|
+
}
|
|
2993
|
+
}
|
|
2994
|
+
function parseQueryParams(queryParams) {
|
|
2995
|
+
return Object.fromEntries(
|
|
2996
|
+
Object.entries(queryParams).map(([key, value]) => [
|
|
2997
|
+
key,
|
|
2998
|
+
value === "null" ? null : value
|
|
2999
|
+
])
|
|
3000
|
+
);
|
|
3001
|
+
}
|
|
3002
|
+
function parseQueriesParams(queriesParams) {
|
|
3003
|
+
return Object.fromEntries(
|
|
3004
|
+
Object.entries(queriesParams).map(([key, values]) => [
|
|
3005
|
+
key,
|
|
3006
|
+
values.map((value) => value === "null" ? null : value)
|
|
3007
|
+
])
|
|
3008
|
+
);
|
|
3009
|
+
}
|
|
3010
|
+
|
|
3011
|
+
// packages/experimental/src/zukhruf/protocol/session.ts
|
|
3012
|
+
var ZUKHRUF_ROUTE_PREFIX = "/zukhruf/v1";
|
|
3013
|
+
var CREATE_SESSION_ROUTE_PATH = "/session";
|
|
3014
|
+
var SESSION_ROUTE_PATH = "/session/:sessionId";
|
|
3015
|
+
var SESSION_CANCEL_ROUTE_PATH = "/session/:sessionId/cancel";
|
|
3016
|
+
var SESSION_STREAM_ROUTE_PATH = "/session/:sessionId/stream";
|
|
3017
|
+
var INFO_ROUTE_PATH = "/info";
|
|
3018
|
+
var HEALTH_ROUTE_PATH = "/health";
|
|
3019
|
+
var ZUKHRUF_CREATE_SESSION_ROUTE_PATH = `${ZUKHRUF_ROUTE_PREFIX}${CREATE_SESSION_ROUTE_PATH}`;
|
|
3020
|
+
var ZUKHRUF_SESSION_ROUTE_PATH = `${ZUKHRUF_ROUTE_PREFIX}${SESSION_ROUTE_PATH}`;
|
|
3021
|
+
var ZUKHRUF_SESSION_CANCEL_ROUTE_PATH = `${ZUKHRUF_ROUTE_PREFIX}${SESSION_CANCEL_ROUTE_PATH}`;
|
|
3022
|
+
var ZUKHRUF_SESSION_STREAM_ROUTE_PATH = `${ZUKHRUF_ROUTE_PREFIX}${SESSION_STREAM_ROUTE_PATH}`;
|
|
3023
|
+
var ZUKHRUF_INFO_ROUTE_PATH = `${ZUKHRUF_ROUTE_PREFIX}${INFO_ROUTE_PATH}`;
|
|
3024
|
+
var ZUKHRUF_HEALTH_ROUTE_PATH = `${ZUKHRUF_ROUTE_PREFIX}${HEALTH_ROUTE_PATH}`;
|
|
3025
|
+
var ZUKHRUF_SESSION_ID_HEADER = "x-zukhruf-session-id";
|
|
3026
|
+
var MAX_BODY_BYTES = 10 * 1024;
|
|
3027
|
+
var MAX_IDEMPOTENCY_KEY_LENGTH = 200;
|
|
3028
|
+
var MAX_INPUT_LENGTH = 8e3;
|
|
3029
|
+
var SESSION_NAMESPACE = uuidv56("urn:deepagents:zukhruf:sessions", uuidv56.URL);
|
|
3030
|
+
var NO_STORE = { "cache-control": "no-store" };
|
|
3031
|
+
var sessionIdSchema = z9.string().refine(validateUuid);
|
|
3032
|
+
var turnBodySchema = z9.strictObject({
|
|
3033
|
+
input: z9.string().trim().min(1).max(MAX_INPUT_LENGTH)
|
|
3034
|
+
});
|
|
3035
|
+
var idempotencyKeySchema = z9.string().trim().min(1).max(MAX_IDEMPOTENCY_KEY_LENGTH);
|
|
3036
|
+
var limitTurnBody = bodyLimit({
|
|
3037
|
+
maxSize: MAX_BODY_BYTES,
|
|
3038
|
+
onError: () => {
|
|
3039
|
+
throw new HTTPException3(413, {
|
|
3040
|
+
message: "Request body is too large",
|
|
3041
|
+
cause: {
|
|
3042
|
+
code: "api/payload-too-large",
|
|
3043
|
+
detail: `Request body exceeds ${MAX_BODY_BYTES} bytes`
|
|
3044
|
+
}
|
|
3045
|
+
});
|
|
3046
|
+
}
|
|
3047
|
+
});
|
|
3048
|
+
function zukhruf(runtime) {
|
|
3049
|
+
const app = new Hono();
|
|
3050
|
+
app.onError((error, context) => {
|
|
3051
|
+
if (error instanceof HTTPException3) {
|
|
3052
|
+
return context.json(
|
|
3053
|
+
{ cause: error.cause, error: error.message },
|
|
3054
|
+
error.status,
|
|
3055
|
+
NO_STORE
|
|
3056
|
+
);
|
|
3057
|
+
}
|
|
3058
|
+
throw error;
|
|
3059
|
+
});
|
|
3060
|
+
app.on(
|
|
3061
|
+
["GET", "HEAD"],
|
|
3062
|
+
HEALTH_ROUTE_PATH,
|
|
3063
|
+
(context) => context.req.method === "HEAD" ? context.body(null, 200, NO_STORE) : context.json({ ok: true }, 200, NO_STORE)
|
|
3064
|
+
);
|
|
3065
|
+
app.all(
|
|
3066
|
+
HEALTH_ROUTE_PATH,
|
|
3067
|
+
(context) => methodNotAllowed(context, "GET, HEAD")
|
|
3068
|
+
);
|
|
3069
|
+
app.use("*", async (context, next) => {
|
|
3070
|
+
if (!context.get("userId")?.trim()) {
|
|
3071
|
+
throw new HTTPException3(401, {
|
|
3072
|
+
message: "Authentication required",
|
|
3073
|
+
cause: {
|
|
3074
|
+
code: "api/unauthenticated",
|
|
3075
|
+
detail: "Authentication required to access Zukhruf"
|
|
3076
|
+
}
|
|
3077
|
+
});
|
|
3078
|
+
}
|
|
3079
|
+
await next();
|
|
3080
|
+
});
|
|
3081
|
+
app.get(
|
|
3082
|
+
INFO_ROUTE_PATH,
|
|
3083
|
+
(context) => context.json(runtime.info, 200, NO_STORE)
|
|
3084
|
+
);
|
|
3085
|
+
app.all(INFO_ROUTE_PATH, (context) => methodNotAllowed(context, "GET"));
|
|
3086
|
+
app.post(
|
|
3087
|
+
CREATE_SESSION_ROUTE_PATH,
|
|
3088
|
+
limitTurnBody,
|
|
3089
|
+
validate("application/json", (payload) => ({
|
|
3090
|
+
body: {
|
|
3091
|
+
select: payload.body,
|
|
3092
|
+
against: turnBodySchema
|
|
3093
|
+
},
|
|
3094
|
+
idempotencyKey: {
|
|
3095
|
+
select: payload.headers["idempotency-key"],
|
|
3096
|
+
against: idempotencyKeySchema
|
|
3097
|
+
}
|
|
3098
|
+
})),
|
|
3099
|
+
async (context) => {
|
|
3100
|
+
const { body, idempotencyKey } = context.var.input;
|
|
3101
|
+
const userId = context.get("userId");
|
|
3102
|
+
const sessionId = uuidv56(
|
|
3103
|
+
JSON.stringify([userId, idempotencyKey]),
|
|
3104
|
+
SESSION_NAMESPACE
|
|
3105
|
+
);
|
|
3106
|
+
const conversation = { chatId: sessionId, userId };
|
|
3107
|
+
await runtime.createSession(conversation);
|
|
3108
|
+
await runtime.enqueue(conversation, {
|
|
3109
|
+
id: idempotencyKey,
|
|
3110
|
+
input: body.input.trim()
|
|
3111
|
+
});
|
|
3112
|
+
return accepted(context, sessionId);
|
|
3113
|
+
}
|
|
3114
|
+
);
|
|
3115
|
+
app.all(
|
|
3116
|
+
CREATE_SESSION_ROUTE_PATH,
|
|
3117
|
+
(context) => methodNotAllowed(context, "POST")
|
|
3118
|
+
);
|
|
3119
|
+
app.post(
|
|
3120
|
+
SESSION_ROUTE_PATH,
|
|
3121
|
+
limitTurnBody,
|
|
3122
|
+
validate("application/json", (payload) => ({
|
|
3123
|
+
body: {
|
|
3124
|
+
select: payload.body,
|
|
3125
|
+
against: turnBodySchema
|
|
3126
|
+
},
|
|
3127
|
+
idempotencyKey: {
|
|
3128
|
+
select: payload.headers["idempotency-key"],
|
|
3129
|
+
against: idempotencyKeySchema
|
|
3130
|
+
},
|
|
3131
|
+
sessionId: {
|
|
3132
|
+
select: payload.params.sessionId,
|
|
3133
|
+
against: sessionIdSchema
|
|
3134
|
+
}
|
|
3135
|
+
})),
|
|
3136
|
+
async (context) => {
|
|
3137
|
+
const { body, idempotencyKey, sessionId } = context.var.input;
|
|
3138
|
+
const conversation = {
|
|
3139
|
+
chatId: sessionId,
|
|
3140
|
+
userId: context.get("userId")
|
|
3141
|
+
};
|
|
3142
|
+
await requireSession(runtime, conversation);
|
|
3143
|
+
await runtime.enqueue(conversation, {
|
|
3144
|
+
id: idempotencyKey,
|
|
3145
|
+
input: body.input.trim()
|
|
3146
|
+
});
|
|
3147
|
+
return accepted(context, sessionId);
|
|
3148
|
+
}
|
|
3149
|
+
);
|
|
3150
|
+
app.all(SESSION_ROUTE_PATH, (context) => methodNotAllowed(context, "POST"));
|
|
3151
|
+
app.post(
|
|
3152
|
+
SESSION_CANCEL_ROUTE_PATH,
|
|
3153
|
+
validate((payload) => ({
|
|
3154
|
+
sessionId: {
|
|
3155
|
+
select: payload.params.sessionId,
|
|
3156
|
+
against: sessionIdSchema
|
|
3157
|
+
}
|
|
3158
|
+
})),
|
|
3159
|
+
async (context) => {
|
|
3160
|
+
const { sessionId } = context.var.input;
|
|
3161
|
+
const conversation = {
|
|
3162
|
+
chatId: sessionId,
|
|
3163
|
+
userId: context.get("userId")
|
|
3164
|
+
};
|
|
3165
|
+
await requireSession(runtime, conversation);
|
|
3166
|
+
await runtime.observe(conversation).cancel();
|
|
3167
|
+
return context.body(null, 204, NO_STORE);
|
|
3168
|
+
}
|
|
3169
|
+
);
|
|
3170
|
+
app.all(
|
|
3171
|
+
SESSION_CANCEL_ROUTE_PATH,
|
|
3172
|
+
(context) => methodNotAllowed(context, "POST")
|
|
3173
|
+
);
|
|
3174
|
+
app.get(
|
|
3175
|
+
SESSION_STREAM_ROUTE_PATH,
|
|
3176
|
+
validate((payload) => ({
|
|
3177
|
+
sessionId: {
|
|
3178
|
+
select: payload.params.sessionId,
|
|
3179
|
+
against: sessionIdSchema
|
|
3180
|
+
}
|
|
3181
|
+
})),
|
|
3182
|
+
async (context) => {
|
|
3183
|
+
const { sessionId } = context.var.input;
|
|
3184
|
+
const conversation = {
|
|
3185
|
+
chatId: sessionId,
|
|
3186
|
+
userId: context.get("userId")
|
|
3187
|
+
};
|
|
3188
|
+
await requireSession(runtime, conversation);
|
|
3189
|
+
const stream = await runtime.observe(conversation).resume();
|
|
3190
|
+
if (!stream) {
|
|
3191
|
+
throw new HTTPException3(404, {
|
|
3192
|
+
message: "Session stream not found",
|
|
3193
|
+
cause: {
|
|
3194
|
+
code: "zukhruf/session-stream-not-found",
|
|
3195
|
+
detail: `No durable stream exists for session ${sessionId}`
|
|
3196
|
+
}
|
|
3197
|
+
});
|
|
3198
|
+
}
|
|
3199
|
+
return createUIMessageStreamResponse({
|
|
3200
|
+
headers: NO_STORE,
|
|
3201
|
+
stream
|
|
3202
|
+
});
|
|
3203
|
+
}
|
|
3204
|
+
);
|
|
3205
|
+
app.all(
|
|
3206
|
+
SESSION_STREAM_ROUTE_PATH,
|
|
3207
|
+
(context) => methodNotAllowed(context, "GET")
|
|
3208
|
+
);
|
|
3209
|
+
return app;
|
|
3210
|
+
}
|
|
3211
|
+
function accepted(context, sessionId) {
|
|
3212
|
+
return context.json({ ok: true, sessionId }, 202, {
|
|
3213
|
+
...NO_STORE,
|
|
3214
|
+
[ZUKHRUF_SESSION_ID_HEADER]: sessionId
|
|
3215
|
+
});
|
|
3216
|
+
}
|
|
3217
|
+
async function requireSession(runtime, conversation) {
|
|
3218
|
+
if (await runtime.sessionExists(conversation)) return;
|
|
3219
|
+
throw new HTTPException3(404, {
|
|
3220
|
+
message: "Session not found",
|
|
3221
|
+
cause: {
|
|
3222
|
+
code: "zukhruf/session-not-found",
|
|
3223
|
+
detail: `Session ${conversation.chatId} does not exist`
|
|
3224
|
+
}
|
|
3225
|
+
});
|
|
3226
|
+
}
|
|
3227
|
+
function methodNotAllowed(context, allow) {
|
|
3228
|
+
context.header("Allow", allow);
|
|
3229
|
+
throw new HTTPException3(405, {
|
|
3230
|
+
message: "Method not allowed",
|
|
3231
|
+
cause: {
|
|
3232
|
+
code: "api/method-not-allowed",
|
|
3233
|
+
detail: `This endpoint only accepts ${allow} requests`
|
|
3234
|
+
}
|
|
3235
|
+
});
|
|
3236
|
+
}
|
|
3237
|
+
|
|
2816
3238
|
// packages/experimental/src/zukhruf/queue/pg-boss.turn-queue.ts
|
|
2817
3239
|
import { v7 as uuidv7 } from "uuid";
|
|
2818
3240
|
|