@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 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 zukhruf = metadata?.zukhruf;
440
- if (typeof treeId !== "string" || !_AgentThread.#isRecord(zukhruf)) {
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 } = zukhruf;
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 zukhruf = metadata?.zukhruf;
863
- if (!isRecord(zukhruf)) {
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 (zukhruf.historyFork !== void 0) {
869
- claimed = parseHistoryForkRecord(zukhruf.historyFork);
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: { ...zukhruf, historyFork: proposed }
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 zukhruf = metadata?.zukhruf;
969
- if (!isRecord(zukhruf)) {
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(zukhruf.historyFork);
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
- ...zukhruf,
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 zukhruf = isRecord2(metadata?.zukhruf) ? metadata.zukhruf : {};
2140
+ const zukhruf2 = isRecord2(metadata?.zukhruf) ? metadata.zukhruf : {};
2129
2141
  return {
2130
2142
  metadata: {
2131
2143
  ...metadata,
2132
- zukhruf: { ...zukhruf, skills: available }
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 zukhruf = metadata?.zukhruf;
2168
- if (!isRecord2(zukhruf) || !Object.hasOwn(zukhruf, "skills")) {
2179
+ const zukhruf2 = metadata?.zukhruf;
2180
+ if (!isRecord2(zukhruf2) || !Object.hasOwn(zukhruf2, "skills")) {
2169
2181
  return void 0;
2170
2182
  }
2171
- if (!Array.isArray(zukhruf.skills) || !zukhruf.skills.every(isSkill)) {
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 zukhruf.skills;
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