@truefoundry/trueforge-core 0.0.0 → 0.1.0-rc.0

package/dist/agent-session/schemas/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/agent-session/schemas/events.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AACtC,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qCAAqC,CAAC;AAsBrF,+EAA+E;AAC/E,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;2BAEN,cAAc;wBACjB,WAAW;CACd,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWL,CAAC;AAE/B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUL,CAAC;AAE5B,qFAAqF;AACrF,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAcL,CAAC;AAE3B,4FAA4F;AAC5F,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAKL,CAAC;AAE/B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,yBAAyB,CAAC,YAAY,CAAC,GAAG;IACzE,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AACF,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,kBAAkB,CAAC;CAC3B"}

package/dist/agent-session/schemas/events.js

@@ -0,0 +1,80 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent-session/schemas/events.ts
+var events_exports = {};
+__export(events_exports, {
+  EventType: () => EventType,
+  SessionEventItemSchema: () => SessionEventItemSchema,
+  SessionEventSchema: () => SessionEventSchema,
+  TurnCreatedEventSchema: () => TurnCreatedEventSchema,
+  TurnDoneEventSchema: () => TurnDoneEventSchema
+});
+module.exports = __toCommonJS(events_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_schema = require("../../core/events/schema.js");
+var import_turn = require("./turn.js");
+var EventType = {
+  ...import_schema.EventType,
+  TURN_CREATED: "turn.created",
+  TURN_DONE: "turn.done"
+};
+var TurnCreatedEventSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal(EventType.TURN_CREATED).describe("Emitted when a turn starts."),
+  id: import_schema.EventIdSchema,
+  turn_id: import_zod_openapi.z.string().describe("Id of the newly created turn."),
+  previous_turn_id: import_zod_openapi.z.string().nullable().describe("Prior turn this turn chains from; null for a root turn."),
+  input: import_zod_openapi.z.array(import_turn.TurnInputItemSchema).optional().describe("Input items supplied when the turn was created."),
+  state: import_turn.TurnStateRunningSchema,
+  created_at: import_zod_openapi.z.string().describe("ISO 8601 event timestamp."),
+  thread_id: import_zod_openapi.z.string().nullable().describe("Thread that owns the event; null for turn-level lifecycle events.")
+}).openapi("TurnCreatedEvent");
+var TurnDoneEventSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal(EventType.TURN_DONE).describe("Emitted when a turn reaches a terminal state."),
+  id: import_schema.EventIdSchema,
+  state: import_zod_openapi.z.discriminatedUnion("status", [import_turn.TurnStateDoneSchema, import_turn.TurnStateCancelledSchema, import_turn.TurnStateErrorSchema]).describe("Terminal turn state (done, cancelled, or error)."),
+  created_at: import_zod_openapi.z.string().describe("ISO 8601 event timestamp."),
+  thread_id: import_zod_openapi.z.string().nullable().describe("Thread that owns the event; null for turn-level lifecycle events.")
+}).openapi("TurnDoneEvent");
+var SessionEventSchema = import_zod_openapi.z.discriminatedUnion("type", [
+  TurnCreatedEventSchema,
+  TurnDoneEventSchema,
+  import_schema.ModelMessageEventSchema,
+  import_schema.ToolResponseEventSchema,
+  import_schema.ThreadCreatedEventSchema,
+  import_schema.ThreadDoneEventSchema,
+  import_schema.MCPAuthRequiredEventSchema,
+  import_schema.MCPInitializeEventSchema,
+  import_schema.SandboxCreatedEventSchema,
+  import_schema.ToolApprovalRequiredEventSchema,
+  import_schema.ToolResponseRequiredEventSchema
+]).openapi("SessionEvent");
+var SessionEventItemSchema = import_zod_openapi.z.object({
+  turn_id: import_zod_openapi.z.string().describe("Turn that emitted this event."),
+  event: SessionEventSchema
+}).openapi("SessionEventItem");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EventType,
+  SessionEventItemSchema,
+  SessionEventSchema,
+  TurnCreatedEventSchema,
+  TurnDoneEventSchema
+});
+//# sourceMappingURL=events.js.map

package/dist/agent-session/schemas/events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agent-session/schemas/events.ts"],"sourcesContent":["/**\n * Turn/session event product schemas. Event payloads come from the harness; this\n * module owns turn lifecycle events (turn.created / turn.done) and the persisted\n * event unions the store writes. SSE streaming envelopes stay in server/schemas.\n */\nimport { z } from '@hono/zod-openapi';\nimport type { WithRegisteredPassthrough } from '../../core/events/PassthroughEvents';\nimport {\n  EventIdSchema,\n  EventType as HarnessEventType,\n  MCPAuthRequiredEventSchema,\n  MCPInitializeEventSchema,\n  ModelMessageEventSchema,\n  SandboxCreatedEventSchema,\n  ThreadCreatedEventSchema,\n  ThreadDoneEventSchema,\n  ToolApprovalRequiredEventSchema,\n  ToolResponseEventSchema,\n  ToolResponseRequiredEventSchema,\n} from '../../core/events/schema';\nimport {\n  TurnInputItemSchema,\n  TurnStateCancelledSchema,\n  TurnStateDoneSchema,\n  TurnStateErrorSchema,\n  TurnStateRunningSchema,\n} from './turn';\n\n/** Harness event types plus the turn lifecycle types owned by agentSession. */\nexport const EventType = {\n  ...HarnessEventType,\n  TURN_CREATED: 'turn.created',\n  TURN_DONE: 'turn.done',\n} as const;\n\nexport const TurnCreatedEventSchema = z\n  .object({\n    type: z.literal(EventType.TURN_CREATED).describe('Emitted when a turn starts.'),\n    id: EventIdSchema,\n    turn_id: z.string().describe('Id of the newly created turn.'),\n    previous_turn_id: z.string().nullable().describe('Prior turn this turn chains from; null for a root turn.'),\n    input: z.array(TurnInputItemSchema).optional().describe('Input items supplied when the turn was created.'),\n    state: TurnStateRunningSchema,\n    created_at: z.string().describe('ISO 8601 event timestamp.'),\n    thread_id: z.string().nullable().describe('Thread that owns the event; null for turn-level lifecycle events.'),\n  })\n  .openapi('TurnCreatedEvent');\n\nexport const TurnDoneEventSchema = z\n  .object({\n    type: z.literal(EventType.TURN_DONE).describe('Emitted when a turn reaches a terminal state.'),\n    id: EventIdSchema,\n    state: z\n      .discriminatedUnion('status', [TurnStateDoneSchema, TurnStateCancelledSchema, TurnStateErrorSchema])\n      .describe('Terminal turn state (done, cancelled, or error).'),\n    created_at: z.string().describe('ISO 8601 event timestamp.'),\n    thread_id: z.string().nullable().describe('Thread that owns the event; null for turn-level lifecycle events.'),\n  })\n  .openapi('TurnDoneEvent');\n\n/** Built-in durable turn events — lifecycle + content; no deltas, no passthrough. */\nexport const SessionEventSchema = z\n  .discriminatedUnion('type', [\n    TurnCreatedEventSchema,\n    TurnDoneEventSchema,\n    ModelMessageEventSchema,\n    ToolResponseEventSchema,\n    ThreadCreatedEventSchema,\n    ThreadDoneEventSchema,\n    MCPAuthRequiredEventSchema,\n    MCPInitializeEventSchema,\n    SandboxCreatedEventSchema,\n    ToolApprovalRequiredEventSchema,\n    ToolResponseRequiredEventSchema,\n  ])\n  .openapi('SessionEvent');\n\n/** One row on the session timeline: which turn emitted the event plus the event payload. */\nexport const SessionEventItemSchema = z\n  .object({\n    turn_id: z.string().describe('Turn that emitted this event.'),\n    event: SessionEventSchema,\n  })\n  .openapi('SessionEventItem');\n\nexport type TurnCreatedEvent = z.infer<typeof TurnCreatedEventSchema>;\nexport type TurnDoneEvent = z.infer<typeof TurnDoneEventSchema>;\nexport type SessionEvent = z.infer<typeof SessionEventSchema>;\n/**\n * Durable turn event log entries: {@link SessionEvent} plus any registered\n * passthrough events. Every merged event must carry its monotonic ULID and\n * creation timestamp; shared by append and list operations.\n */\nexport type PersistedTurnEvent = WithRegisteredPassthrough<SessionEvent> & {\n  id: string;\n  created_at: string;\n};\nexport interface SessionEventItem {\n  turn_id: string;\n  event: PersistedTurnEvent;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,yBAAkB;AAElB,oBAYO;AACP,kBAMO;AAGA,IAAM,YAAY;AAAA,EACvB,GAAG,cAAAA;AAAA,EACH,cAAc;AAAA,EACd,WAAW;AACb;AAEO,IAAM,yBAAyB,qBACnC,OAAO;AAAA,EACN,MAAM,qBAAE,QAAQ,UAAU,YAAY,EAAE,SAAS,6BAA6B;AAAA,EAC9E,IAAI;AAAA,EACJ,SAAS,qBAAE,OAAO,EAAE,SAAS,+BAA+B;AAAA,EAC5D,kBAAkB,qBAAE,OAAO,EAAE,SAAS,EAAE,SAAS,yDAAyD;AAAA,EAC1G,OAAO,qBAAE,MAAM,+BAAmB,EAAE,SAAS,EAAE,SAAS,iDAAiD;AAAA,EACzG,OAAO;AAAA,EACP,YAAY,qBAAE,OAAO,EAAE,SAAS,2BAA2B;AAAA,EAC3D,WAAW,qBAAE,OAAO,EAAE,SAAS,EAAE,SAAS,mEAAmE;AAC/G,CAAC,EACA,QAAQ,kBAAkB;AAEtB,IAAM,sBAAsB,qBAChC,OAAO;AAAA,EACN,MAAM,qBAAE,QAAQ,UAAU,SAAS,EAAE,SAAS,+CAA+C;AAAA,EAC7F,IAAI;AAAA,EACJ,OAAO,qBACJ,mBAAmB,UAAU,CAAC,iCAAqB,sCAA0B,gCAAoB,CAAC,EAClG,SAAS,kDAAkD;AAAA,EAC9D,YAAY,qBAAE,OAAO,EAAE,SAAS,2BAA2B;AAAA,EAC3D,WAAW,qBAAE,OAAO,EAAE,SAAS,EAAE,SAAS,mEAAmE;AAC/G,CAAC,EACA,QAAQ,eAAe;AAGnB,IAAM,qBAAqB,qBAC/B,mBAAmB,QAAQ;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC,EACA,QAAQ,cAAc;AAGlB,IAAM,yBAAyB,qBACnC,OAAO;AAAA,EACN,SAAS,qBAAE,OAAO,EAAE,SAAS,+BAA+B;AAAA,EAC5D,OAAO;AACT,CAAC,EACA,QAAQ,kBAAkB;","names":["HarnessEventType"]}

package/dist/agent-session/schemas/events.mjs

@@ -0,0 +1,69 @@
+// src/agent-session/schemas/events.ts
+import { z } from "@hono/zod-openapi";
+import {
+  EventIdSchema,
+  EventType as HarnessEventType,
+  MCPAuthRequiredEventSchema,
+  MCPInitializeEventSchema,
+  ModelMessageEventSchema,
+  SandboxCreatedEventSchema,
+  ThreadCreatedEventSchema,
+  ThreadDoneEventSchema,
+  ToolApprovalRequiredEventSchema,
+  ToolResponseEventSchema,
+  ToolResponseRequiredEventSchema
+} from "../../core/events/schema.mjs";
+import {
+  TurnInputItemSchema,
+  TurnStateCancelledSchema,
+  TurnStateDoneSchema,
+  TurnStateErrorSchema,
+  TurnStateRunningSchema
+} from "./turn.mjs";
+var EventType = {
+  ...HarnessEventType,
+  TURN_CREATED: "turn.created",
+  TURN_DONE: "turn.done"
+};
+var TurnCreatedEventSchema = z.object({
+  type: z.literal(EventType.TURN_CREATED).describe("Emitted when a turn starts."),
+  id: EventIdSchema,
+  turn_id: z.string().describe("Id of the newly created turn."),
+  previous_turn_id: z.string().nullable().describe("Prior turn this turn chains from; null for a root turn."),
+  input: z.array(TurnInputItemSchema).optional().describe("Input items supplied when the turn was created."),
+  state: TurnStateRunningSchema,
+  created_at: z.string().describe("ISO 8601 event timestamp."),
+  thread_id: z.string().nullable().describe("Thread that owns the event; null for turn-level lifecycle events.")
+}).openapi("TurnCreatedEvent");
+var TurnDoneEventSchema = z.object({
+  type: z.literal(EventType.TURN_DONE).describe("Emitted when a turn reaches a terminal state."),
+  id: EventIdSchema,
+  state: z.discriminatedUnion("status", [TurnStateDoneSchema, TurnStateCancelledSchema, TurnStateErrorSchema]).describe("Terminal turn state (done, cancelled, or error)."),
+  created_at: z.string().describe("ISO 8601 event timestamp."),
+  thread_id: z.string().nullable().describe("Thread that owns the event; null for turn-level lifecycle events.")
+}).openapi("TurnDoneEvent");
+var SessionEventSchema = z.discriminatedUnion("type", [
+  TurnCreatedEventSchema,
+  TurnDoneEventSchema,
+  ModelMessageEventSchema,
+  ToolResponseEventSchema,
+  ThreadCreatedEventSchema,
+  ThreadDoneEventSchema,
+  MCPAuthRequiredEventSchema,
+  MCPInitializeEventSchema,
+  SandboxCreatedEventSchema,
+  ToolApprovalRequiredEventSchema,
+  ToolResponseRequiredEventSchema
+]).openapi("SessionEvent");
+var SessionEventItemSchema = z.object({
+  turn_id: z.string().describe("Turn that emitted this event."),
+  event: SessionEventSchema
+}).openapi("SessionEventItem");
+export {
+  EventType,
+  SessionEventItemSchema,
+  SessionEventSchema,
+  TurnCreatedEventSchema,
+  TurnDoneEventSchema
+};
+//# sourceMappingURL=events.mjs.map

package/dist/agent-session/schemas/events.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agent-session/schemas/events.ts"],"sourcesContent":["/**\n * Turn/session event product schemas. Event payloads come from the harness; this\n * module owns turn lifecycle events (turn.created / turn.done) and the persisted\n * event unions the store writes. SSE streaming envelopes stay in server/schemas.\n */\nimport { z } from '@hono/zod-openapi';\nimport type { WithRegisteredPassthrough } from '../../core/events/PassthroughEvents';\nimport {\n  EventIdSchema,\n  EventType as HarnessEventType,\n  MCPAuthRequiredEventSchema,\n  MCPInitializeEventSchema,\n  ModelMessageEventSchema,\n  SandboxCreatedEventSchema,\n  ThreadCreatedEventSchema,\n  ThreadDoneEventSchema,\n  ToolApprovalRequiredEventSchema,\n  ToolResponseEventSchema,\n  ToolResponseRequiredEventSchema,\n} from '../../core/events/schema';\nimport {\n  TurnInputItemSchema,\n  TurnStateCancelledSchema,\n  TurnStateDoneSchema,\n  TurnStateErrorSchema,\n  TurnStateRunningSchema,\n} from './turn';\n\n/** Harness event types plus the turn lifecycle types owned by agentSession. */\nexport const EventType = {\n  ...HarnessEventType,\n  TURN_CREATED: 'turn.created',\n  TURN_DONE: 'turn.done',\n} as const;\n\nexport const TurnCreatedEventSchema = z\n  .object({\n    type: z.literal(EventType.TURN_CREATED).describe('Emitted when a turn starts.'),\n    id: EventIdSchema,\n    turn_id: z.string().describe('Id of the newly created turn.'),\n    previous_turn_id: z.string().nullable().describe('Prior turn this turn chains from; null for a root turn.'),\n    input: z.array(TurnInputItemSchema).optional().describe('Input items supplied when the turn was created.'),\n    state: TurnStateRunningSchema,\n    created_at: z.string().describe('ISO 8601 event timestamp.'),\n    thread_id: z.string().nullable().describe('Thread that owns the event; null for turn-level lifecycle events.'),\n  })\n  .openapi('TurnCreatedEvent');\n\nexport const TurnDoneEventSchema = z\n  .object({\n    type: z.literal(EventType.TURN_DONE).describe('Emitted when a turn reaches a terminal state.'),\n    id: EventIdSchema,\n    state: z\n      .discriminatedUnion('status', [TurnStateDoneSchema, TurnStateCancelledSchema, TurnStateErrorSchema])\n      .describe('Terminal turn state (done, cancelled, or error).'),\n    created_at: z.string().describe('ISO 8601 event timestamp.'),\n    thread_id: z.string().nullable().describe('Thread that owns the event; null for turn-level lifecycle events.'),\n  })\n  .openapi('TurnDoneEvent');\n\n/** Built-in durable turn events — lifecycle + content; no deltas, no passthrough. */\nexport const SessionEventSchema = z\n  .discriminatedUnion('type', [\n    TurnCreatedEventSchema,\n    TurnDoneEventSchema,\n    ModelMessageEventSchema,\n    ToolResponseEventSchema,\n    ThreadCreatedEventSchema,\n    ThreadDoneEventSchema,\n    MCPAuthRequiredEventSchema,\n    MCPInitializeEventSchema,\n    SandboxCreatedEventSchema,\n    ToolApprovalRequiredEventSchema,\n    ToolResponseRequiredEventSchema,\n  ])\n  .openapi('SessionEvent');\n\n/** One row on the session timeline: which turn emitted the event plus the event payload. */\nexport const SessionEventItemSchema = z\n  .object({\n    turn_id: z.string().describe('Turn that emitted this event.'),\n    event: SessionEventSchema,\n  })\n  .openapi('SessionEventItem');\n\nexport type TurnCreatedEvent = z.infer<typeof TurnCreatedEventSchema>;\nexport type TurnDoneEvent = z.infer<typeof TurnDoneEventSchema>;\nexport type SessionEvent = z.infer<typeof SessionEventSchema>;\n/**\n * Durable turn event log entries: {@link SessionEvent} plus any registered\n * passthrough events. Every merged event must carry its monotonic ULID and\n * creation timestamp; shared by append and list operations.\n */\nexport type PersistedTurnEvent = WithRegisteredPassthrough<SessionEvent> & {\n  id: string;\n  created_at: string;\n};\nexport interface SessionEventItem {\n  turn_id: string;\n  event: PersistedTurnEvent;\n}\n"],"mappings":";AAKA,SAAS,SAAS;AAElB;AAAA,EACE;AAAA,EACA,aAAa;AAAA,EACb;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAGA,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,cAAc;AAAA,EACd,WAAW;AACb;AAEO,IAAM,yBAAyB,EACnC,OAAO;AAAA,EACN,MAAM,EAAE,QAAQ,UAAU,YAAY,EAAE,SAAS,6BAA6B;AAAA,EAC9E,IAAI;AAAA,EACJ,SAAS,EAAE,OAAO,EAAE,SAAS,+BAA+B;AAAA,EAC5D,kBAAkB,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,yDAAyD;AAAA,EAC1G,OAAO,EAAE,MAAM,mBAAmB,EAAE,SAAS,EAAE,SAAS,iDAAiD;AAAA,EACzG,OAAO;AAAA,EACP,YAAY,EAAE,OAAO,EAAE,SAAS,2BAA2B;AAAA,EAC3D,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,mEAAmE;AAC/G,CAAC,EACA,QAAQ,kBAAkB;AAEtB,IAAM,sBAAsB,EAChC,OAAO;AAAA,EACN,MAAM,EAAE,QAAQ,UAAU,SAAS,EAAE,SAAS,+CAA+C;AAAA,EAC7F,IAAI;AAAA,EACJ,OAAO,EACJ,mBAAmB,UAAU,CAAC,qBAAqB,0BAA0B,oBAAoB,CAAC,EAClG,SAAS,kDAAkD;AAAA,EAC9D,YAAY,EAAE,OAAO,EAAE,SAAS,2BAA2B;AAAA,EAC3D,WAAW,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,mEAAmE;AAC/G,CAAC,EACA,QAAQ,eAAe;AAGnB,IAAM,qBAAqB,EAC/B,mBAAmB,QAAQ;AAAA,EAC1B;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC,EACA,QAAQ,cAAc;AAGlB,IAAM,yBAAyB,EACnC,OAAO;AAAA,EACN,SAAS,EAAE,OAAO,EAAE,SAAS,+BAA+B;AAAA,EAC5D,OAAO;AACT,CAAC,EACA,QAAQ,kBAAkB;","names":[]}

package/dist/agent-session/schemas/pagination.d.ts

@@ -0,0 +1,9 @@
+/** Token pagination wire schema. */
+import { z } from '@hono/zod-openapi';
+export declare const TokenPaginationSchema: z.ZodObject<{
+    next_page_token: z.ZodOptional<z.ZodString>;
+    previous_page_token: z.ZodOptional<z.ZodString>;
+    limit: z.ZodNumber;
+}, z.core.$strip>;
+export type TokenPagination = z.infer<typeof TokenPaginationSchema>;
+//# sourceMappingURL=pagination.d.ts.map

package/dist/agent-session/schemas/pagination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.d.ts","sourceRoot":"","sources":["../../../src/agent-session/schemas/pagination.ts"],"names":[],"mappings":"AAAA,oCAAoC;AACpC,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAEtC,eAAO,MAAM,qBAAqB;;;;iBAYL,CAAC;AAE9B,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/agent-session/schemas/pagination.js

@@ -0,0 +1,36 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent-session/schemas/pagination.ts
+var pagination_exports = {};
+__export(pagination_exports, {
+  TokenPaginationSchema: () => TokenPaginationSchema
+});
+module.exports = __toCommonJS(pagination_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var TokenPaginationSchema = import_zod_openapi.z.object({
+  next_page_token: import_zod_openapi.z.string().optional().describe("Opaque token for the next page. Omit or absent when there is no next page."),
+  previous_page_token: import_zod_openapi.z.string().optional().describe("Opaque token for the previous page. Omit or absent when there is no previous page."),
+  limit: import_zod_openapi.z.number().int().positive().describe("Page size used for this response.")
+}).openapi("TokenPagination");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TokenPaginationSchema
+});
+//# sourceMappingURL=pagination.js.map

package/dist/agent-session/schemas/pagination.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agent-session/schemas/pagination.ts"],"sourcesContent":["/** Token pagination wire schema. */\nimport { z } from '@hono/zod-openapi';\n\nexport const TokenPaginationSchema = z\n  .object({\n    next_page_token: z\n      .string()\n      .optional()\n      .describe('Opaque token for the next page. Omit or absent when there is no next page.'),\n    previous_page_token: z\n      .string()\n      .optional()\n      .describe('Opaque token for the previous page. Omit or absent when there is no previous page.'),\n    limit: z.number().int().positive().describe('Page size used for this response.'),\n  })\n  .openapi('TokenPagination');\n\nexport type TokenPagination = z.infer<typeof TokenPaginationSchema>;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,yBAAkB;AAEX,IAAM,wBAAwB,qBAClC,OAAO;AAAA,EACN,iBAAiB,qBACd,OAAO,EACP,SAAS,EACT,SAAS,4EAA4E;AAAA,EACxF,qBAAqB,qBAClB,OAAO,EACP,SAAS,EACT,SAAS,oFAAoF;AAAA,EAChG,OAAO,qBAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,mCAAmC;AACjF,CAAC,EACA,QAAQ,iBAAiB;","names":[]}

package/dist/agent-session/schemas/pagination.mjs

@@ -0,0 +1,11 @@
+// src/agent-session/schemas/pagination.ts
+import { z } from "@hono/zod-openapi";
+var TokenPaginationSchema = z.object({
+  next_page_token: z.string().optional().describe("Opaque token for the next page. Omit or absent when there is no next page."),
+  previous_page_token: z.string().optional().describe("Opaque token for the previous page. Omit or absent when there is no previous page."),
+  limit: z.number().int().positive().describe("Page size used for this response.")
+}).openapi("TokenPagination");
+export {
+  TokenPaginationSchema
+};
+//# sourceMappingURL=pagination.mjs.map

package/dist/agent-session/schemas/pagination.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/agent-session/schemas/pagination.ts"],"sourcesContent":["/** Token pagination wire schema. */\nimport { z } from '@hono/zod-openapi';\n\nexport const TokenPaginationSchema = z\n  .object({\n    next_page_token: z\n      .string()\n      .optional()\n      .describe('Opaque token for the next page. Omit or absent when there is no next page.'),\n    previous_page_token: z\n      .string()\n      .optional()\n      .describe('Opaque token for the previous page. Omit or absent when there is no previous page.'),\n    limit: z.number().int().positive().describe('Page size used for this response.'),\n  })\n  .openapi('TokenPagination');\n\nexport type TokenPagination = z.infer<typeof TokenPaginationSchema>;\n"],"mappings":";AACA,SAAS,SAAS;AAEX,IAAM,wBAAwB,EAClC,OAAO;AAAA,EACN,iBAAiB,EACd,OAAO,EACP,SAAS,EACT,SAAS,4EAA4E;AAAA,EACxF,qBAAqB,EAClB,OAAO,EACP,SAAS,EACT,SAAS,oFAAoF;AAAA,EAChG,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,mCAAmC;AACjF,CAAC,EACA,QAAQ,iBAAiB;","names":[]}

package/dist/agent-session/schemas/session.d.ts

@@ -0,0 +1,319 @@
+/**
+ * Session product schemas. Agent binding is a single discriminated `agent`
+ * field (`reference` | `inline`). DB stores agent_id / agent_name / agent_spec columns.
+ */
+import { z } from '@hono/zod-openapi';
+export declare const SessionAgentReferenceSchema: z.ZodObject<{
+    type: z.ZodLiteral<"reference">;
+    id: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const SessionAgentInlineSchema: z.ZodObject<{
+    type: z.ZodLiteral<"inline">;
+    spec: z.ZodObject<{
+        model: z.ZodObject<{
+            name: z.ZodString;
+            params: z.ZodOptional<z.ZodObject<{
+                max_tokens: z.ZodOptional<z.ZodNumber>;
+                temperature: z.ZodOptional<z.ZodNumber>;
+                top_p: z.ZodOptional<z.ZodNumber>;
+                top_k: z.ZodOptional<z.ZodNumber>;
+                parallel_tool_calls: z.ZodOptional<z.ZodBoolean>;
+                reasoning_effort: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$strip>;
+        instructions: z.ZodOptional<z.ZodString>;
+        messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"user.message">;
+            content: z.ZodString;
+        }, z.core.$strip>>>;
+        mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            enable_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "@all": "@all";
+                "@read-only": "@read-only";
+            }>, z.ZodString]>>>;
+            disable_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "@all": "@all";
+                "@read-only": "@read-only";
+            }>, z.ZodString]>>>;
+            preload_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "@all": "@all";
+                "@read-only": "@read-only";
+            }>, z.ZodString]>>>;
+            require_approval_for_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "@all": "@all";
+                "@destructive": "@destructive";
+                "@write": "@write";
+            }>, z.ZodString]>>>;
+            preload: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+        response_format: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"json_object">;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"json_schema">;
+            json_schema: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, z.core.$loose>;
+        }, z.core.$loose>], "type">>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+        config: z.ZodDefault<z.ZodObject<{
+            iteration_limit: z.ZodDefault<z.ZodNumber>;
+            sandbox: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodBoolean;
+                file_downloads: z.ZodDefault<z.ZodBoolean>;
+                network_policy: z.ZodOptional<z.ZodObject<{
+                    auth_inject: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        type: z.ZodLiteral<"git">;
+                        match: z.ZodObject<{
+                            hosts: z.ZodArray<z.ZodString>;
+                        }, z.core.$strip>;
+                        auth_data: z.ZodObject<{
+                            type: z.ZodLiteral<"basic">;
+                            username: z.ZodString;
+                            password: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            dynamic_sub_agents: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            context_management: z.ZodDefault<z.ZodObject<{
+                compaction: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    compaction_threshold_tokens: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                large_tool_response: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            generative_ui: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            ask_user_questions: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+/** Named registry binding or inline AgentSpec — exactly one arm. */
+export declare const SessionAgentSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"reference">;
+    id: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"inline">;
+    spec: z.ZodObject<{
+        model: z.ZodObject<{
+            name: z.ZodString;
+            params: z.ZodOptional<z.ZodObject<{
+                max_tokens: z.ZodOptional<z.ZodNumber>;
+                temperature: z.ZodOptional<z.ZodNumber>;
+                top_p: z.ZodOptional<z.ZodNumber>;
+                top_k: z.ZodOptional<z.ZodNumber>;
+                parallel_tool_calls: z.ZodOptional<z.ZodBoolean>;
+                reasoning_effort: z.ZodOptional<z.ZodString>;
+            }, z.core.$loose>>;
+        }, z.core.$strip>;
+        instructions: z.ZodOptional<z.ZodString>;
+        messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            type: z.ZodLiteral<"user.message">;
+            content: z.ZodString;
+        }, z.core.$strip>>>;
+        mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            enable_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "@all": "@all";
+                "@read-only": "@read-only";
+            }>, z.ZodString]>>>;
+            disable_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "@all": "@all";
+                "@read-only": "@read-only";
+            }>, z.ZodString]>>>;
+            preload_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "@all": "@all";
+                "@read-only": "@read-only";
+            }>, z.ZodString]>>>;
+            require_approval_for_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                "@all": "@all";
+                "@destructive": "@destructive";
+                "@write": "@write";
+            }>, z.ZodString]>>>;
+            preload: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>>>;
+        response_format: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"json_object">;
+        }, z.core.$loose>, z.ZodObject<{
+            type: z.ZodLiteral<"json_schema">;
+            json_schema: z.ZodObject<{
+                name: z.ZodString;
+                description: z.ZodOptional<z.ZodString>;
+                schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, z.core.$loose>;
+        }, z.core.$loose>], "type">>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>>>;
+        config: z.ZodDefault<z.ZodObject<{
+            iteration_limit: z.ZodDefault<z.ZodNumber>;
+            sandbox: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodBoolean;
+                file_downloads: z.ZodDefault<z.ZodBoolean>;
+                network_policy: z.ZodOptional<z.ZodObject<{
+                    auth_inject: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        type: z.ZodLiteral<"git">;
+                        match: z.ZodObject<{
+                            hosts: z.ZodArray<z.ZodString>;
+                        }, z.core.$strip>;
+                        auth_data: z.ZodObject<{
+                            type: z.ZodLiteral<"basic">;
+                            username: z.ZodString;
+                            password: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            dynamic_sub_agents: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            context_management: z.ZodDefault<z.ZodObject<{
+                compaction: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                    compaction_threshold_tokens: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                large_tool_response: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+            generative_ui: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+            ask_user_questions: z.ZodDefault<z.ZodObject<{
+                enabled: z.ZodDefault<z.ZodBoolean>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strict>], "type">;
+export declare const SessionSchema: z.ZodObject<{
+    id: z.ZodString;
+    agent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"reference">;
+        id: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"inline">;
+        spec: z.ZodObject<{
+            model: z.ZodObject<{
+                name: z.ZodString;
+                params: z.ZodOptional<z.ZodObject<{
+                    max_tokens: z.ZodOptional<z.ZodNumber>;
+                    temperature: z.ZodOptional<z.ZodNumber>;
+                    top_p: z.ZodOptional<z.ZodNumber>;
+                    top_k: z.ZodOptional<z.ZodNumber>;
+                    parallel_tool_calls: z.ZodOptional<z.ZodBoolean>;
+                    reasoning_effort: z.ZodOptional<z.ZodString>;
+                }, z.core.$loose>>;
+            }, z.core.$strip>;
+            instructions: z.ZodOptional<z.ZodString>;
+            messages: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"user.message">;
+                content: z.ZodString;
+            }, z.core.$strip>>>;
+            mcp_servers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                enable_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                    "@all": "@all";
+                    "@read-only": "@read-only";
+                }>, z.ZodString]>>>;
+                disable_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                    "@all": "@all";
+                    "@read-only": "@read-only";
+                }>, z.ZodString]>>>;
+                preload_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                    "@all": "@all";
+                    "@read-only": "@read-only";
+                }>, z.ZodString]>>>;
+                require_approval_for_tools: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodEnum<{
+                    "@all": "@all";
+                    "@destructive": "@destructive";
+                    "@write": "@write";
+                }>, z.ZodString]>>>;
+                preload: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            }, z.core.$strip>>>;
+            response_format: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"text">;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"json_object">;
+            }, z.core.$loose>, z.ZodObject<{
+                type: z.ZodLiteral<"json_schema">;
+                json_schema: z.ZodObject<{
+                    name: z.ZodString;
+                    description: z.ZodOptional<z.ZodString>;
+                    schema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    strict: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                }, z.core.$loose>;
+            }, z.core.$loose>], "type">>;
+            skills: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+            }, z.core.$strict>>>;
+            config: z.ZodDefault<z.ZodObject<{
+                iteration_limit: z.ZodDefault<z.ZodNumber>;
+                sandbox: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    file_downloads: z.ZodDefault<z.ZodBoolean>;
+                    network_policy: z.ZodOptional<z.ZodObject<{
+                        auth_inject: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            type: z.ZodLiteral<"git">;
+                            match: z.ZodObject<{
+                                hosts: z.ZodArray<z.ZodString>;
+                            }, z.core.$strip>;
+                            auth_data: z.ZodObject<{
+                                type: z.ZodLiteral<"basic">;
+                                username: z.ZodString;
+                                password: z.ZodString;
+                            }, z.core.$strip>;
+                        }, z.core.$strip>>>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                dynamic_sub_agents: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                context_management: z.ZodDefault<z.ZodObject<{
+                    compaction: z.ZodDefault<z.ZodObject<{
+                        enabled: z.ZodDefault<z.ZodBoolean>;
+                        compaction_threshold_tokens: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strip>>;
+                    large_tool_response: z.ZodDefault<z.ZodObject<{
+                        enabled: z.ZodDefault<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>>;
+                generative_ui: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                ask_user_questions: z.ZodDefault<z.ZodObject<{
+                    enabled: z.ZodDefault<z.ZodBoolean>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    }, z.core.$strict>], "type">;
+    title: z.ZodNullable<z.ZodString>;
+    created_by: z.ZodString;
+    created_at: z.ZodString;
+    updated_at: z.ZodString;
+}, z.core.$strip>;
+export type SessionAgentReference = z.infer<typeof SessionAgentReferenceSchema>;
+export type SessionAgentInline = z.infer<typeof SessionAgentInlineSchema>;
+export type SessionAgent = z.infer<typeof SessionAgentSchema>;
+export type Session = z.infer<typeof SessionSchema>;
+//# sourceMappingURL=session.d.ts.map

package/dist/agent-session/schemas/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../src/agent-session/schemas/session.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,mBAAmB,CAAC;AAGtC,eAAO,MAAM,2BAA2B;;;;kBAWL,CAAC;AAEpC,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAML,CAAC;AAEjC,oEAAoE;AACpE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAEL,CAAC;AAE3B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUL,CAAC;AAEtB,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/agent-session/schemas/session.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/agent-session/schemas/session.ts
+var session_exports = {};
+__export(session_exports, {
+  SessionAgentInlineSchema: () => SessionAgentInlineSchema,
+  SessionAgentReferenceSchema: () => SessionAgentReferenceSchema,
+  SessionAgentSchema: () => SessionAgentSchema,
+  SessionSchema: () => SessionSchema
+});
+module.exports = __toCommonJS(session_exports);
+var import_zod_openapi = require("@hono/zod-openapi");
+var import_agentSpec = require("./agentSpec.js");
+var SessionAgentReferenceSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("reference").describe("Bind the session to a named registry agent."),
+  id: import_zod_openapi.z.string().min(1).describe("Registry agent id."),
+  /** Create-time snapshot of the registry agent name; null for legacy/orphan rows. */
+  name: import_zod_openapi.z.string().nullable().describe("Create-time snapshot of the registry agent name; null for legacy or orphan rows.")
+}).strict().openapi("SessionAgentReference");
+var SessionAgentInlineSchema = import_zod_openapi.z.object({
+  type: import_zod_openapi.z.literal("inline").describe("Bind the session to an inline AgentSpec (not a registry id)."),
+  spec: import_agentSpec.AgentSpecSchema
+}).strict().openapi("SessionAgentInline");
+var SessionAgentSchema = import_zod_openapi.z.discriminatedUnion("type", [SessionAgentReferenceSchema, SessionAgentInlineSchema]).openapi("SessionAgent");
+var SessionSchema = import_zod_openapi.z.object({
+  id: import_zod_openapi.z.string().describe("Unique session id."),
+  agent: SessionAgentSchema,
+  title: import_zod_openapi.z.string().nullable().describe("Optional human-readable title; null until set."),
+  /** Caller identity that created the session (immutable). */
+  created_by: import_zod_openapi.z.string().describe("Caller identity that created the session (immutable)."),
+  created_at: import_zod_openapi.z.string().describe("ISO 8601 creation timestamp."),
+  updated_at: import_zod_openapi.z.string().describe("ISO 8601 last-update timestamp.")
+}).openapi("Session");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SessionAgentInlineSchema,
+  SessionAgentReferenceSchema,
+  SessionAgentSchema,
+  SessionSchema
+});
+//# sourceMappingURL=session.js.map