@shipfox/api-logs-dto 2.0.0

package/dist/schemas/record.js

@@ -0,0 +1,136 @@
+import { z } from 'zod';
+import { sessionViewRowSchema } from './session-view.js';
+/**
+ * NDJSON log record contract — one JSON object per line, runner-framed.
+ *
+ * `offset` / `committed_length` are byte positions in the raw append NDJSON spool stream
+ * (envelope included) — the offset-CAS axis the runner tracks. The per-job accrual
+ * budget charges the normalized NDJSON bytes the server stores, so framing and control records
+ * count against it too. The per-record byte caps below bound each record so a single
+ * entry's overhead is known and a runner cannot grow storage without moving the
+ * budget: `data` is non-empty and <= MAX_RECORD_DATA_BYTES, the group `name` is
+ * <= MAX_RECORD_NAME_BYTES, the group ids are <= MAX_RECORD_GROUP_ID_BYTES, and every
+ * other field is fixed-shape.
+ *
+ * The envelope is `{v, ts}`, and every record is discriminated by a single flat
+ * `type`. The raw/write and stored/read unions are distinct types: the server-only
+ * `capped` / `runner_lost` tombstones are members of the read union only, so a forged
+ * tombstone cannot pass append validation.
+ *
+ * The append-side `agent_session` record carries one verbatim agent session entry line
+ * in `data`, forwarded opaquely by the runner. On successful ingest, the API normalizes
+ * that raw entry into one or more read-side `agent_session` records whose `row` is the
+ * canonical session view row. The raw and normalized records travel through the same log
+ * append/read pipe; only their contract at each boundary differs.
+ */ /** Largest decoded `data` payload per record. Longer lines are split by the runner. */ export const MAX_RECORD_DATA_BYTES = 16 * 1024;
+/** Largest `group_start` name. Bounds the only variable-length control field. */ export const MAX_RECORD_NAME_BYTES = 1024;
+/**
+ * Largest `group_id` / `parent_group_id`. The runner emits short monotonic ids (`g1`,
+ * `g2`, …); this only bounds a forged id from a lease-scoped writer so the ids stay a
+ * fixed-shape field like every other record field.
+ */ export const MAX_RECORD_GROUP_ID_BYTES = 256;
+// UTF-8 byte length without node:buffer, so this shared DTO stays browser-safe (the
+// client log viewer imports these types too). Identical to Buffer.byteLength(x, 'utf8').
+const utf8Encoder = new TextEncoder();
+const utf8ByteLength = (value)=>utf8Encoder.encode(value).length;
+const groupId = z.string().min(1, {
+    message: 'group id must not be empty'
+}).refine((value)=>utf8ByteLength(value) <= MAX_RECORD_GROUP_ID_BYTES, {
+    message: `group id exceeds ${MAX_RECORD_GROUP_ID_BYTES} bytes`
+});
+const envelope = {
+    v: z.literal(1),
+    /** Epoch milliseconds, assigned by the runner at capture. */ ts: z.number().int().nonnegative()
+};
+const logOutput = z.object({
+    ...envelope,
+    type: z.literal('output'),
+    stream: z.enum([
+        'stdout',
+        'stderr'
+    ]),
+    data: z.string().min(1, {
+        message: 'output data must not be empty'
+    }).refine((value)=>utf8ByteLength(value) <= MAX_RECORD_DATA_BYTES, {
+        message: `data exceeds ${MAX_RECORD_DATA_BYTES} payload bytes`
+    })
+});
+const logGroupStart = z.object({
+    ...envelope,
+    type: z.literal('group_start'),
+    group_id: groupId,
+    parent_group_id: groupId.nullable(),
+    name: z.string().refine((value)=>utf8ByteLength(value) <= MAX_RECORD_NAME_BYTES, {
+        message: `group name exceeds ${MAX_RECORD_NAME_BYTES} bytes`
+    })
+});
+const logGroupEnd = z.object({
+    ...envelope,
+    type: z.literal('group_end'),
+    group_id: groupId
+});
+const logEnd = z.object({
+    ...envelope,
+    type: z.literal('end'),
+    total_bytes: z.number().int().nonnegative()
+});
+const logGap = z.object({
+    ...envelope,
+    type: z.literal('gap'),
+    dropped_bytes: z.number().int().nonnegative()
+});
+// One verbatim agent session entry line, forwarded opaquely by the runner. `data` is
+// intentionally uncapped here: the per-line byte limit is the server's configurable
+// LOG_MAX_SESSION_LINE_BYTES (a Zod schema cannot read runtime config, and a static cap
+// would collide with the body-limit invariant), enforced in the append write path.
+const rawAgentSession = z.object({
+    ...envelope,
+    type: z.literal('agent_session'),
+    data: z.string().min(1, {
+        message: 'agent_session data must not be empty'
+    })
+});
+const agentSession = z.object({
+    ...envelope,
+    type: z.literal('agent_session'),
+    row: sessionViewRowSchema
+});
+// Server-only tombstones: NOT members of the raw write union.
+const logCapped = z.object({
+    ...envelope,
+    type: z.literal('capped')
+});
+const logRunnerLost = z.object({
+    ...envelope,
+    type: z.literal('runner_lost')
+});
+/** Records a lease-scoped runner may append. The write path validates against this. */ export const rawLogRecordSchema = z.discriminatedUnion('type', [
+    logOutput,
+    logGroupStart,
+    logGroupEnd,
+    logEnd,
+    logGap,
+    rawAgentSession
+]);
+/** Stored/read records: regular records, normalized agent sessions, and tombstones. */ export const logRecordSchema = z.discriminatedUnion('type', [
+    logOutput,
+    logGroupStart,
+    logGroupEnd,
+    logEnd,
+    logGap,
+    agentSession,
+    logCapped,
+    logRunnerLost
+]);
+export function parseLogRecordLine(line) {
+    return logRecordSchema.parse(JSON.parse(line));
+}
+/**
+ * Parses one NDJSON line against the raw write union. A forged
+ * server-only `capped` / `runner_lost` record fails here even though it is valid
+ * under the read union — this is the write-path forgery guard.
+ */ export function parseRawLogRecordLine(line) {
+    return rawLogRecordSchema.parse(JSON.parse(line));
+}
+
+//# sourceMappingURL=record.js.map

package/dist/schemas/record.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/record.ts"],"sourcesContent":["import {z} from 'zod';\nimport {sessionViewRowSchema} from './session-view.js';\n\n/**\n * NDJSON log record contract — one JSON object per line, runner-framed.\n *\n * `offset` / `committed_length` are byte positions in the raw append NDJSON spool stream\n * (envelope included) — the offset-CAS axis the runner tracks. The per-job accrual\n * budget charges the normalized NDJSON bytes the server stores, so framing and control records\n * count against it too. The per-record byte caps below bound each record so a single\n * entry's overhead is known and a runner cannot grow storage without moving the\n * budget: `data` is non-empty and <= MAX_RECORD_DATA_BYTES, the group `name` is\n * <= MAX_RECORD_NAME_BYTES, the group ids are <= MAX_RECORD_GROUP_ID_BYTES, and every\n * other field is fixed-shape.\n *\n * The envelope is `{v, ts}`, and every record is discriminated by a single flat\n * `type`. The raw/write and stored/read unions are distinct types: the server-only\n * `capped` / `runner_lost` tombstones are members of the read union only, so a forged\n * tombstone cannot pass append validation.\n *\n * The append-side `agent_session` record carries one verbatim agent session entry line\n * in `data`, forwarded opaquely by the runner. On successful ingest, the API normalizes\n * that raw entry into one or more read-side `agent_session` records whose `row` is the\n * canonical session view row. The raw and normalized records travel through the same log\n * append/read pipe; only their contract at each boundary differs.\n */\n\n/** Largest decoded `data` payload per record. Longer lines are split by the runner. */\nexport const MAX_RECORD_DATA_BYTES = 16 * 1024;\n\n/** Largest `group_start` name. Bounds the only variable-length control field. */\nexport const MAX_RECORD_NAME_BYTES = 1024;\n\n/**\n * Largest `group_id` / `parent_group_id`. The runner emits short monotonic ids (`g1`,\n * `g2`, …); this only bounds a forged id from a lease-scoped writer so the ids stay a\n * fixed-shape field like every other record field.\n */\nexport const MAX_RECORD_GROUP_ID_BYTES = 256;\n\n// UTF-8 byte length without node:buffer, so this shared DTO stays browser-safe (the\n// client log viewer imports these types too). Identical to Buffer.byteLength(x, 'utf8').\nconst utf8Encoder = new TextEncoder();\nconst utf8ByteLength = (value: string): number => utf8Encoder.encode(value).length;\n\nconst groupId = z\n  .string()\n  .min(1, {message: 'group id must not be empty'})\n  .refine((value) => utf8ByteLength(value) <= MAX_RECORD_GROUP_ID_BYTES, {\n    message: `group id exceeds ${MAX_RECORD_GROUP_ID_BYTES} bytes`,\n  });\n\nconst envelope = {\n  v: z.literal(1),\n  /** Epoch milliseconds, assigned by the runner at capture. */\n  ts: z.number().int().nonnegative(),\n};\n\nconst logOutput = z.object({\n  ...envelope,\n  type: z.literal('output'),\n  stream: z.enum(['stdout', 'stderr']),\n  data: z\n    .string()\n    .min(1, {message: 'output data must not be empty'})\n    .refine((value) => utf8ByteLength(value) <= MAX_RECORD_DATA_BYTES, {\n      message: `data exceeds ${MAX_RECORD_DATA_BYTES} payload bytes`,\n    }),\n});\n\nconst logGroupStart = z.object({\n  ...envelope,\n  type: z.literal('group_start'),\n  group_id: groupId,\n  parent_group_id: groupId.nullable(),\n  name: z.string().refine((value) => utf8ByteLength(value) <= MAX_RECORD_NAME_BYTES, {\n    message: `group name exceeds ${MAX_RECORD_NAME_BYTES} bytes`,\n  }),\n});\n\nconst logGroupEnd = z.object({...envelope, type: z.literal('group_end'), group_id: groupId});\n\nconst logEnd = z.object({\n  ...envelope,\n  type: z.literal('end'),\n  total_bytes: z.number().int().nonnegative(),\n});\n\nconst logGap = z.object({\n  ...envelope,\n  type: z.literal('gap'),\n  dropped_bytes: z.number().int().nonnegative(),\n});\n\n// One verbatim agent session entry line, forwarded opaquely by the runner. `data` is\n// intentionally uncapped here: the per-line byte limit is the server's configurable\n// LOG_MAX_SESSION_LINE_BYTES (a Zod schema cannot read runtime config, and a static cap\n// would collide with the body-limit invariant), enforced in the append write path.\nconst rawAgentSession = z.object({\n  ...envelope,\n  type: z.literal('agent_session'),\n  data: z.string().min(1, {message: 'agent_session data must not be empty'}),\n});\n\nconst agentSession = z.object({\n  ...envelope,\n  type: z.literal('agent_session'),\n  row: sessionViewRowSchema,\n});\n\n// Server-only tombstones: NOT members of the raw write union.\nconst logCapped = z.object({...envelope, type: z.literal('capped')});\nconst logRunnerLost = z.object({...envelope, type: z.literal('runner_lost')});\n\n/** Records a lease-scoped runner may append. The write path validates against this. */\nexport const rawLogRecordSchema = z.discriminatedUnion('type', [\n  logOutput,\n  logGroupStart,\n  logGroupEnd,\n  logEnd,\n  logGap,\n  rawAgentSession,\n]);\n\n/** Stored/read records: regular records, normalized agent sessions, and tombstones. */\nexport const logRecordSchema = z.discriminatedUnion('type', [\n  logOutput,\n  logGroupStart,\n  logGroupEnd,\n  logEnd,\n  logGap,\n  agentSession,\n  logCapped,\n  logRunnerLost,\n]);\n\nexport type RawLogRecord = z.infer<typeof rawLogRecordSchema>;\nexport type LogRecord = z.infer<typeof logRecordSchema>;\n\nexport function parseLogRecordLine(line: string): LogRecord {\n  return logRecordSchema.parse(JSON.parse(line));\n}\n\n/**\n * Parses one NDJSON line against the raw write union. A forged\n * server-only `capped` / `runner_lost` record fails here even though it is valid\n * under the read union — this is the write-path forgery guard.\n */\nexport function parseRawLogRecordLine(line: string): RawLogRecord {\n  return rawLogRecordSchema.parse(JSON.parse(line));\n}\n"],"names":["z","sessionViewRowSchema","MAX_RECORD_DATA_BYTES","MAX_RECORD_NAME_BYTES","MAX_RECORD_GROUP_ID_BYTES","utf8Encoder","TextEncoder","utf8ByteLength","value","encode","length","groupId","string","min","message","refine","envelope","v","literal","ts","number","int","nonnegative","logOutput","object","type","stream","enum","data","logGroupStart","group_id","parent_group_id","nullable","name","logGroupEnd","logEnd","total_bytes","logGap","dropped_bytes","rawAgentSession","agentSession","row","logCapped","logRunnerLost","rawLogRecordSchema","discriminatedUnion","logRecordSchema","parseLogRecordLine","line","parse","JSON","parseRawLogRecordLine"],"mappings":"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"}

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

@@ -0,0 +1,178 @@
+import { z } from 'zod';
+export declare const SESSION_VIEW_VERSION = 1;
+export declare const sessionViewRowMetaSchema: z.ZodObject<{
+    label: z.ZodString;
+    value: z.ZodString;
+    inline: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export declare const sessionViewMessageRowSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"message">;
+    role: z.ZodString;
+    label: z.ZodString;
+    meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        inline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    text: z.ZodString;
+    terminalFailure: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const sessionViewThinkingRowSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"thinking">;
+    text: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const sessionViewToolCallRowSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"tool-call">;
+    id: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    input: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const sessionViewToolResultRowSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"tool-result">;
+    toolCallId: z.ZodNullable<z.ZodString>;
+    toolName: z.ZodString;
+    output: z.ZodString;
+    isError: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const sessionViewLifecycleRowSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"lifecycle">;
+    label: z.ZodString;
+    detail: z.ZodNullable<z.ZodString>;
+    meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        inline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    tone: z.ZodEnum<{
+        error: "error";
+        default: "default";
+        warning: "warning";
+    }>;
+    terminalFailure: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const sessionViewRawRowSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"raw">;
+    label: z.ZodString;
+    raw: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export declare const sessionViewRowSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"message">;
+    role: z.ZodString;
+    label: z.ZodString;
+    meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        inline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    text: z.ZodString;
+    terminalFailure: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"thinking">;
+    text: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"tool-call">;
+    id: z.ZodNullable<z.ZodString>;
+    name: z.ZodString;
+    input: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"tool-result">;
+    toolCallId: z.ZodNullable<z.ZodString>;
+    toolName: z.ZodString;
+    output: z.ZodString;
+    isError: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"lifecycle">;
+    label: z.ZodString;
+    detail: z.ZodNullable<z.ZodString>;
+    meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        value: z.ZodString;
+        inline: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    tone: z.ZodEnum<{
+        error: "error";
+        default: "default";
+        warning: "warning";
+    }>;
+    terminalFailure: z.ZodBoolean;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"raw">;
+    label: z.ZodString;
+    raw: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>], "kind">;
+export declare const sessionViewSchema: z.ZodObject<{
+    v: z.ZodLiteral<1>;
+    rows: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"message">;
+        role: z.ZodString;
+        label: z.ZodString;
+        meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+            inline: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        text: z.ZodString;
+        terminalFailure: z.ZodBoolean;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"thinking">;
+        text: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"tool-call">;
+        id: z.ZodNullable<z.ZodString>;
+        name: z.ZodString;
+        input: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"tool-result">;
+        toolCallId: z.ZodNullable<z.ZodString>;
+        toolName: z.ZodString;
+        output: z.ZodString;
+        isError: z.ZodBoolean;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"lifecycle">;
+        label: z.ZodString;
+        detail: z.ZodNullable<z.ZodString>;
+        meta: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodString;
+            inline: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
+        tone: z.ZodEnum<{
+            error: "error";
+            default: "default";
+            warning: "warning";
+        }>;
+        terminalFailure: z.ZodBoolean;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"raw">;
+        label: z.ZodString;
+        raw: z.ZodString;
+        timestamp: z.ZodNumber;
+    }, z.core.$strip>], "kind">>>;
+}, z.core.$strip>;
+export type SessionViewRowMeta = z.infer<typeof sessionViewRowMetaSchema>;
+export type SessionViewMessageRow = z.infer<typeof sessionViewMessageRowSchema>;
+export type SessionViewThinkingRow = z.infer<typeof sessionViewThinkingRowSchema>;
+export type SessionViewToolCallRow = z.infer<typeof sessionViewToolCallRowSchema>;
+export type SessionViewToolResultRow = z.infer<typeof sessionViewToolResultRowSchema>;
+export type SessionViewLifecycleRow = z.infer<typeof sessionViewLifecycleRowSchema>;
+export type SessionViewRawRow = z.infer<typeof sessionViewRawRowSchema>;
+export type SessionViewRow = z.infer<typeof sessionViewRowSchema>;
+export type SessionViewDto = z.infer<typeof sessionViewSchema>;
+//# sourceMappingURL=session-view.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session-view.d.ts","sourceRoot":"","sources":["../../src/schemas/session-view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAItC,eAAO,MAAM,wBAAwB;;;;iBAInC,CAAC;AAMH,eAAO,MAAM,2BAA2B;;;;;;;;;;;;iBAQtC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;iBAIvC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;iBAMvC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;iBAOzC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;iBAQxC,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;;iBAKlC,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAO/B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAG5B,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAChF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAClF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AACtF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AACpF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/schemas/session-view.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+export const SESSION_VIEW_VERSION = 1;
+const timestampSchema = z.number().int().nonnegative();
+export const sessionViewRowMetaSchema = z.object({
+    label: z.string().min(1),
+    value: z.string(),
+    inline: z.boolean().optional()
+});
+const sessionViewRowBase = {
+    timestamp: timestampSchema
+};
+export const sessionViewMessageRowSchema = z.object({
+    ...sessionViewRowBase,
+    kind: z.literal('message'),
+    role: z.string().min(1),
+    label: z.string().min(1),
+    meta: z.array(sessionViewRowMetaSchema).readonly(),
+    text: z.string(),
+    terminalFailure: z.boolean()
+});
+export const sessionViewThinkingRowSchema = z.object({
+    ...sessionViewRowBase,
+    kind: z.literal('thinking'),
+    text: z.string()
+});
+export const sessionViewToolCallRowSchema = z.object({
+    ...sessionViewRowBase,
+    kind: z.literal('tool-call'),
+    id: z.string().nullable(),
+    name: z.string().min(1),
+    input: z.string()
+});
+export const sessionViewToolResultRowSchema = z.object({
+    ...sessionViewRowBase,
+    kind: z.literal('tool-result'),
+    toolCallId: z.string().nullable(),
+    toolName: z.string().min(1),
+    output: z.string(),
+    isError: z.boolean()
+});
+export const sessionViewLifecycleRowSchema = z.object({
+    ...sessionViewRowBase,
+    kind: z.literal('lifecycle'),
+    label: z.string().min(1),
+    detail: z.string().nullable(),
+    meta: z.array(sessionViewRowMetaSchema).readonly(),
+    tone: z.enum([
+        'default',
+        'warning',
+        'error'
+    ]),
+    terminalFailure: z.boolean()
+});
+export const sessionViewRawRowSchema = z.object({
+    ...sessionViewRowBase,
+    kind: z.literal('raw'),
+    label: z.string().min(1),
+    raw: z.string()
+});
+export const sessionViewRowSchema = z.discriminatedUnion('kind', [
+    sessionViewMessageRowSchema,
+    sessionViewThinkingRowSchema,
+    sessionViewToolCallRowSchema,
+    sessionViewToolResultRowSchema,
+    sessionViewLifecycleRowSchema,
+    sessionViewRawRowSchema
+]);
+export const sessionViewSchema = z.object({
+    v: z.literal(SESSION_VIEW_VERSION),
+    rows: z.array(sessionViewRowSchema).readonly()
+});
+
+//# sourceMappingURL=session-view.js.map

package/dist/schemas/session-view.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/schemas/session-view.ts"],"sourcesContent":["import {z} from 'zod';\n\nexport const SESSION_VIEW_VERSION = 1;\n\nconst timestampSchema = z.number().int().nonnegative();\n\nexport const sessionViewRowMetaSchema = z.object({\n  label: z.string().min(1),\n  value: z.string(),\n  inline: z.boolean().optional(),\n});\n\nconst sessionViewRowBase = {\n  timestamp: timestampSchema,\n};\n\nexport const sessionViewMessageRowSchema = z.object({\n  ...sessionViewRowBase,\n  kind: z.literal('message'),\n  role: z.string().min(1),\n  label: z.string().min(1),\n  meta: z.array(sessionViewRowMetaSchema).readonly(),\n  text: z.string(),\n  terminalFailure: z.boolean(),\n});\n\nexport const sessionViewThinkingRowSchema = z.object({\n  ...sessionViewRowBase,\n  kind: z.literal('thinking'),\n  text: z.string(),\n});\n\nexport const sessionViewToolCallRowSchema = z.object({\n  ...sessionViewRowBase,\n  kind: z.literal('tool-call'),\n  id: z.string().nullable(),\n  name: z.string().min(1),\n  input: z.string(),\n});\n\nexport const sessionViewToolResultRowSchema = z.object({\n  ...sessionViewRowBase,\n  kind: z.literal('tool-result'),\n  toolCallId: z.string().nullable(),\n  toolName: z.string().min(1),\n  output: z.string(),\n  isError: z.boolean(),\n});\n\nexport const sessionViewLifecycleRowSchema = z.object({\n  ...sessionViewRowBase,\n  kind: z.literal('lifecycle'),\n  label: z.string().min(1),\n  detail: z.string().nullable(),\n  meta: z.array(sessionViewRowMetaSchema).readonly(),\n  tone: z.enum(['default', 'warning', 'error']),\n  terminalFailure: z.boolean(),\n});\n\nexport const sessionViewRawRowSchema = z.object({\n  ...sessionViewRowBase,\n  kind: z.literal('raw'),\n  label: z.string().min(1),\n  raw: z.string(),\n});\n\nexport const sessionViewRowSchema = z.discriminatedUnion('kind', [\n  sessionViewMessageRowSchema,\n  sessionViewThinkingRowSchema,\n  sessionViewToolCallRowSchema,\n  sessionViewToolResultRowSchema,\n  sessionViewLifecycleRowSchema,\n  sessionViewRawRowSchema,\n]);\n\nexport const sessionViewSchema = z.object({\n  v: z.literal(SESSION_VIEW_VERSION),\n  rows: z.array(sessionViewRowSchema).readonly(),\n});\n\nexport type SessionViewRowMeta = z.infer<typeof sessionViewRowMetaSchema>;\nexport type SessionViewMessageRow = z.infer<typeof sessionViewMessageRowSchema>;\nexport type SessionViewThinkingRow = z.infer<typeof sessionViewThinkingRowSchema>;\nexport type SessionViewToolCallRow = z.infer<typeof sessionViewToolCallRowSchema>;\nexport type SessionViewToolResultRow = z.infer<typeof sessionViewToolResultRowSchema>;\nexport type SessionViewLifecycleRow = z.infer<typeof sessionViewLifecycleRowSchema>;\nexport type SessionViewRawRow = z.infer<typeof sessionViewRawRowSchema>;\nexport type SessionViewRow = z.infer<typeof sessionViewRowSchema>;\nexport type SessionViewDto = z.infer<typeof sessionViewSchema>;\n"],"names":["z","SESSION_VIEW_VERSION","timestampSchema","number","int","nonnegative","sessionViewRowMetaSchema","object","label","string","min","value","inline","boolean","optional","sessionViewRowBase","timestamp","sessionViewMessageRowSchema","kind","literal","role","meta","array","readonly","text","terminalFailure","sessionViewThinkingRowSchema","sessionViewToolCallRowSchema","id","nullable","name","input","sessionViewToolResultRowSchema","toolCallId","toolName","output","isError","sessionViewLifecycleRowSchema","detail","tone","enum","sessionViewRawRowSchema","raw","sessionViewRowSchema","discriminatedUnion","sessionViewSchema","v","rows"],"mappings":"AAAA,SAAQA,CAAC,QAAO,MAAM;AAEtB,OAAO,MAAMC,uBAAuB,EAAE;AAEtC,MAAMC,kBAAkBF,EAAEG,MAAM,GAAGC,GAAG,GAAGC,WAAW;AAEpD,OAAO,MAAMC,2BAA2BN,EAAEO,MAAM,CAAC;IAC/CC,OAAOR,EAAES,MAAM,GAAGC,GAAG,CAAC;IACtBC,OAAOX,EAAES,MAAM;IACfG,QAAQZ,EAAEa,OAAO,GAAGC,QAAQ;AAC9B,GAAG;AAEH,MAAMC,qBAAqB;IACzBC,WAAWd;AACb;AAEA,OAAO,MAAMe,8BAA8BjB,EAAEO,MAAM,CAAC;IAClD,GAAGQ,kBAAkB;IACrBG,MAAMlB,EAAEmB,OAAO,CAAC;IAChBC,MAAMpB,EAAES,MAAM,GAAGC,GAAG,CAAC;IACrBF,OAAOR,EAAES,MAAM,GAAGC,GAAG,CAAC;IACtBW,MAAMrB,EAAEsB,KAAK,CAAChB,0BAA0BiB,QAAQ;IAChDC,MAAMxB,EAAES,MAAM;IACdgB,iBAAiBzB,EAAEa,OAAO;AAC5B,GAAG;AAEH,OAAO,MAAMa,+BAA+B1B,EAAEO,MAAM,CAAC;IACnD,GAAGQ,kBAAkB;IACrBG,MAAMlB,EAAEmB,OAAO,CAAC;IAChBK,MAAMxB,EAAES,MAAM;AAChB,GAAG;AAEH,OAAO,MAAMkB,+BAA+B3B,EAAEO,MAAM,CAAC;IACnD,GAAGQ,kBAAkB;IACrBG,MAAMlB,EAAEmB,OAAO,CAAC;IAChBS,IAAI5B,EAAES,MAAM,GAAGoB,QAAQ;IACvBC,MAAM9B,EAAES,MAAM,GAAGC,GAAG,CAAC;IACrBqB,OAAO/B,EAAES,MAAM;AACjB,GAAG;AAEH,OAAO,MAAMuB,iCAAiChC,EAAEO,MAAM,CAAC;IACrD,GAAGQ,kBAAkB;IACrBG,MAAMlB,EAAEmB,OAAO,CAAC;IAChBc,YAAYjC,EAAES,MAAM,GAAGoB,QAAQ;IAC/BK,UAAUlC,EAAES,MAAM,GAAGC,GAAG,CAAC;IACzByB,QAAQnC,EAAES,MAAM;IAChB2B,SAASpC,EAAEa,OAAO;AACpB,GAAG;AAEH,OAAO,MAAMwB,gCAAgCrC,EAAEO,MAAM,CAAC;IACpD,GAAGQ,kBAAkB;IACrBG,MAAMlB,EAAEmB,OAAO,CAAC;IAChBX,OAAOR,EAAES,MAAM,GAAGC,GAAG,CAAC;IACtB4B,QAAQtC,EAAES,MAAM,GAAGoB,QAAQ;IAC3BR,MAAMrB,EAAEsB,KAAK,CAAChB,0BAA0BiB,QAAQ;IAChDgB,MAAMvC,EAAEwC,IAAI,CAAC;QAAC;QAAW;QAAW;KAAQ;IAC5Cf,iBAAiBzB,EAAEa,OAAO;AAC5B,GAAG;AAEH,OAAO,MAAM4B,0BAA0BzC,EAAEO,MAAM,CAAC;IAC9C,GAAGQ,kBAAkB;IACrBG,MAAMlB,EAAEmB,OAAO,CAAC;IAChBX,OAAOR,EAAES,MAAM,GAAGC,GAAG,CAAC;IACtBgC,KAAK1C,EAAES,MAAM;AACf,GAAG;AAEH,OAAO,MAAMkC,uBAAuB3C,EAAE4C,kBAAkB,CAAC,QAAQ;IAC/D3B;IACAS;IACAC;IACAK;IACAK;IACAI;CACD,EAAE;AAEH,OAAO,MAAMI,oBAAoB7C,EAAEO,MAAM,CAAC;IACxCuC,GAAG9C,EAAEmB,OAAO,CAAClB;IACb8C,MAAM/C,EAAEsB,KAAK,CAACqB,sBAAsBpB,QAAQ;AAC9C,GAAG"}