@tai42/api-client 19.3.0 → 21.0.0

package/src/schemas/tools.ts

@@ -1,59 +1,39 @@
 /** Tool catalog, run-result and per-tool tag response schemas. */
 import { z } from 'zod';
 
-import { jsonSchema, jsonValue } from './shared';
+import * as openapi from '../generated/openapi-schemas';
 
-export const toolNames = z.array(z.string());
+export const toolNames = openapi.stringListResponse;
 
-export const toolSchema = z.object({
-  input: jsonSchema,
-  output: jsonSchema.nullable(),
-  description: z.string().nullable(),
-});
+export const toolSchema = openapi.toolSchemaView;
 export type ToolSchema = z.infer<typeof toolSchema>;
 
-export const allToolSchemas = z.record(z.string(), toolSchema);
+export const allToolSchemas = openapi.toolsSchemaMap;
 
-export const runToolResult = jsonValue;
+/**
+ * What a synchronous run answers, by `kind`: `result` (the tool's own value in `result`),
+ * `asks` (the tool asked its CALLER and parked: the caller asks and the suspension), `parked`
+ * (only user asks remain: the suspension) or `none` (nothing ran).
+ */
+export const runAnswer = openapi.runAnswerResponse;
+export type RunAnswer = z.infer<typeof runAnswer>;
+
+export const runToolResult = runAnswer;
 
 /** The lifecycle status a parked interaction on a run's subject carries: a pending ask, an
  * ask whose continuation is resuming, or a resolved run's waiting outcome (clean/failed). */
-export const parkedStatus = z.enum(['asking', 'running', 'finished', 'failed']);
+export const parkedStatus = openapi.parkedEntry.shape.status;
 export type ParkedStatus = z.infer<typeof parkedStatus>;
 
 /**
  * One parked caller-ask entry a synchronous run-tool call returns when the tool asked its
- * CALLER (`to="caller"`) and parked. The full contract entry carries more fields; the panel
- * reads the display subset here and tolerates the rest. `question` is the prompt, `payload`
- * the structured value the ask handed the caller, `asked_by` the run chain that raised it.
+ * CALLER (`to="caller"`) and parked. `question` is the prompt, `payload` the structured
+ * value the ask handed the caller, `asked_by` the run chain that raised it.
  */
-export const parkedCallerAsk = z.object({
-  id: z.string(),
-  status: parkedStatus,
-  to: z.enum(['user', 'caller']).nullish(),
-  question: z.string().nullish(),
-  payload: z.record(z.string(), z.unknown()).nullish(),
-  asked_by: z.array(z.string()).nullish(),
-});
+export const parkedCallerAsk = openapi.parkedEntry;
 export type ParkedCallerAsk = z.infer<typeof parkedCallerAsk>;
 
-/** A synchronous run whose tool parked CALLER asks returns this envelope in place of a result:
- * the full caller-ask entries under `asks`. An empty `asks` means the run parked with no open
- * caller ask (only user asks remain). */
-export const callerAsksEnvelope = z.object({
-  asks: z.array(parkedCallerAsk),
-});
-export type CallerAsksEnvelope = z.infer<typeof callerAsksEnvelope>;
-
-/** The park receipt a synchronous run returns when its tool parked only USER asks: the
- * suspension sentinel's ids, with no caller ask for the panel to act on. */
-export const suspendedRunReceipt = z.object({
-  interaction_id: z.string(),
-  interaction_ids: z.array(z.string()),
-  caller_interaction_ids: z.array(z.string()).default([]),
-});
-export type SuspendedRunReceipt = z.infer<typeof suspendedRunReceipt>;
-
+// Hand-written: a `resume_parked` / `cancel_parked` tool's own result, opaque to the spec.
 /** What one resume / take / cancel of a parked interaction did, as `resume_parked` /
  * `cancel_parked` return it through run-tool. `kind` picks the payload: `result` (a final
  * value in `result`), `asks` (new caller asks in `asks`), `parked` (only user asks remain),
@@ -67,6 +47,7 @@ export const visitOutcome = z.object({
 });
 export type VisitOutcome = z.infer<typeof visitOutcome>;
 
+// Hand-written: a third-party media block inside a tool's own result, opaque to the spec.
 /**
  * The MEDIA content shape a direct tool run may return — fastmcp's serialized
  * `Image`/`Audio` MediaBlock (`{ type, data: <base64>, mimeType }`). One recognised
@@ -102,12 +83,8 @@ export type ToolMediaResult = z.infer<typeof toolMediaResult>;
  * `badges` are the tool's plugin-DECLARED capability labels — purely INFORMATIONAL
  * (e.g. `network`, `filesystem`), never a gate the server enforces. The overlay's
  * own badges are merged on top client-side; this read exposes only the declaration.
+ * `schedulable` is whether the tool can be scheduled.
  */
-export const toolTagEntry = z.object({
-  name: z.string(),
-  tags: z.array(z.string()),
-  badges: z.array(z.string()),
-  hidden: z.boolean(),
-});
-export const toolTags = z.array(toolTagEntry);
+export const toolTagEntry = openapi.toolTagRow;
+export const toolTags = openapi.toolTagListResponse;
 export type ToolTagEntry = z.infer<typeof toolTagEntry>;

package/src/schemas/trigger-links.ts

@@ -1,7 +1,7 @@
 /** Trigger-link record and lifecycle response schemas. */
-import { z } from 'zod';
+import type { z } from 'zod';
 
-import { triggerAuth } from './hooks';
+import * as openapi from '../generated/openapi-schemas';
 
 // A trigger link is a minted, token-bearing PUBLIC URL (`GET|POST /trigger/{token}`)
 // that resolves to a hook TOPIC and fires it. Studio mints, lists, and revokes them
@@ -14,13 +14,7 @@ import { triggerAuth } from './hooks';
  * (nothing else stores or lists it — a listed link's QR is unrecoverable by
  * design). `expires_at` is an ISO-8601 instant, or `null` for a permanent link.
  */
-export const triggerLinkCreated = z.object({
-  name: z.string(),
-  trigger_path: z.string(),
-  token: z.string(),
-  topic: z.string(),
-  expires_at: z.string().nullable(),
-});
+export const triggerLinkCreated = openapi.triggerLinkCreated;
 export type TriggerLinkCreated = z.infer<typeof triggerLinkCreated>;
 
 /**
@@ -28,28 +22,16 @@ export type TriggerLinkCreated = z.infer<typeof triggerLinkCreated>;
  * is the per-link params merged last into every fire (`null` or `{}` = none);
  * `created_by` is the ambient creator identity (`null` on an identity-less,
  * gate-off deployment); `token_hash_prefix` is a short hash prefix for log
- * correlation — never a raw token (none is stored).
+ * correlation — never a raw token (none is stored); `execution_key_fingerprint` names
+ * the key a fire runs as, and `require_api_key` is whether a fire must also carry one.
  */
-export const triggerLinkRecord = z.object({
-  name: z.string(),
-  topic: z.string(),
-  execution_key: z.string().min(1),
-  trigger_auth: triggerAuth,
-  tool_kwargs: z.record(z.string(), z.unknown()).nullable(),
-  created_by: z.string().nullable(),
-  created_at: z.string(),
-  expires_at: z.string().nullable(),
-  token_hash_prefix: z.string(),
-});
+export const triggerLinkRecord = openapi.triggerLinkView;
 export type TriggerLinkRecord = z.infer<typeof triggerLinkRecord>;
 
 /** `GET /api/hooks/trigger-links` — every live trigger-link record. */
-export const triggerLinkList = z.object({
-  items: z.array(triggerLinkRecord),
-  total: z.number(),
-});
+export const triggerLinkList = openapi.triggerLinkListView;
 export type TriggerLinkList = z.infer<typeof triggerLinkList>;
 
 /** `DELETE /api/hooks/trigger-links/{name}` — the revoked link. */
-export const triggerLinkDeleted = z.object({ removed: z.boolean(), name: z.string() });
+export const triggerLinkDeleted = openapi.removedByName;
 export type TriggerLinkDeleted = z.infer<typeof triggerLinkDeleted>;

package/src/tool-runs.ts

@@ -14,10 +14,16 @@
  */
 import { z } from 'zod';
 
+import { apiRoutes, buildPath } from './generated/api-routes';
+import {
+  runAsksAnswer,
+  runParkedAnswer,
+  toolRunListItem as generatedToolRunListItem,
+  toolRunView,
+} from './generated/openapi-schemas';
 import type { ApiConfig } from './http';
-import { apiRequest, encodeSegment } from './http';
+import { apiRequest } from './http';
 import type { StateSubject } from './schemas/states';
-import { callerAsksEnvelope, suspendedRunReceipt } from './schemas/tools';
 
 /** A run's lifecycle state. `lost` = the server restarted mid-run; the result is
  * unrecoverable. `parked` = the run's tool async-parked; its `result` is the park
@@ -29,40 +35,38 @@ export const toolRunSubmitResult = z.object({
   run_id: z.string(),
 });
 
-/** `GET /api/tool-runs/{run_id}` → the full record. `result` is arbitrary JSON: the
- * tool's own value on `succeeded`, the park answer ({@link toolRunParkAnswer}) on
- * `parked`. `error` is present only on `failed`. `resumed_interactions` is the parked
- * interaction ids the run resumed or took while it executed (`[]` when it resumed none). */
-export const toolRunRecord = z.object({
-  run_id: z.string(),
-  tool_name: z.string(),
-  status: toolRunStatus,
-  started_at: z.string(),
-  finished_at: z.string().optional(),
-  result: z.unknown().optional(),
-  error: z.string().optional(),
-  resumed_interactions: z.array(z.string()).optional(),
-});
-
-/** One entry of `GET /api/tool-runs?tool_name=...` — id/status/timestamps only,
- * deliberately carrying NO `result`/`error` (the list is not secret-bearing). */
-export const toolRunListItem = z.object({
-  run_id: z.string(),
-  tool_name: z.string(),
-  status: toolRunStatus,
-  started_at: z.string(),
-  finished_at: z.string().optional(),
-});
-
-export const toolRunList = z.array(toolRunListItem);
+/**
+ * The `result` a `parked` record carries: the run answer the synchronous run-tool door
+ * returns, restricted to its two park kinds — `asks` (the tool asked its CALLER and parked)
+ * or `parked` (only USER asks remain).
+ */
+export const toolRunParkAnswer = z.discriminatedUnion('kind', [runAsksAnswer, runParkedAnswer]);
 
 /**
- * The `result` a `parked` record carries — the SAME park answer the synchronous run-tool
- * door returns: either the caller-ask envelope `{asks: [...]}` (the tool asked its CALLER
- * and parked) or the suspension receipt (the run parked only USER asks, ids only). A poller
- * reads it to tell a caller-ask park from a user-only one, exactly as the sync door's caller does.
+ * `GET /api/tool-runs/{run_id}` → the full record, the published `ToolRunView` narrowed by
+ * `status` into one variant per lifecycle state. `result` is the tool's own value on
+ * `succeeded` and, on `parked`, the park answer ({@link toolRunParkAnswer}) parsed here so a
+ * reader switches on its `kind`; a parked record whose stored answer is not one of the two park
+ * kinds is refused on the read. `error` carries a `failed` run's message; `outcome` is set only
+ * on a `failed` record whose run reached a failed terminal: the run's outcome, whole, as the
+ * sync door delivers it (`error` is then the plain `tool run failed`). `resumed_interactions` is
+ * the parked interaction ids the run resumed or took while it executed (`[]` when it resumed
+ * none).
  */
-export const toolRunParkAnswer = z.union([callerAsksEnvelope, suspendedRunReceipt]);
+export const toolRunRecord = z.discriminatedUnion('status', [
+  toolRunView.extend({ status: z.literal('running') }),
+  toolRunView.extend({ status: z.literal('succeeded') }),
+  toolRunView.extend({ status: z.literal('failed') }),
+  toolRunView.extend({ status: z.literal('lost') }),
+  toolRunView.extend({ status: z.literal('parked'), result: toolRunParkAnswer }),
+]);
+
+/** One entry of `GET /api/tool-runs?tool_name=...` — the published list row (id, status,
+ * timestamps; never `result`/`error`, the list is not secret-bearing), its `status` narrowed to
+ * the lifecycle states. */
+export const toolRunListItem = generatedToolRunListItem.extend({ status: toolRunStatus });
+
+export const toolRunList = z.array(toolRunListItem);
 
 export type ToolRunStatus = z.infer<typeof toolRunStatus>;
 export type ToolRunParkAnswer = z.infer<typeof toolRunParkAnswer>;
@@ -85,7 +89,7 @@ export function submitToolRun(
   args: SubmitToolRunArgs,
   signal?: AbortSignal,
 ): Promise<ToolRunSubmitResult> {
-  return apiRequest(config, '/api/tool-runs', toolRunSubmitResult, {
+  return apiRequest(config, apiRoutes.post_api_tool_runs.path, toolRunSubmitResult, {
     method: 'POST',
     body: {
       tool_name: args.tool_name,
@@ -102,9 +106,14 @@ export function getToolRun(
   runId: string,
   signal?: AbortSignal,
 ): Promise<ToolRunRecord> {
-  return apiRequest(config, `/api/tool-runs/${encodeSegment(runId)}`, toolRunRecord, {
-    signal,
-  });
+  return apiRequest(
+    config,
+    buildPath(apiRoutes.get_api_tool_runs_run_id.path, { run_id: runId }),
+    toolRunRecord,
+    {
+      signal,
+    },
+  );
 }
 
 /** List the recent background runs for one tool (newest first). */
@@ -113,7 +122,7 @@ export function listToolRuns(
   toolName: string,
   signal?: AbortSignal,
 ): Promise<ToolRunListItem[]> {
-  return apiRequest(config, '/api/tool-runs', toolRunList, {
+  return apiRequest(config, apiRoutes.get_api_tool_runs.path, toolRunList, {
     query: { tool_name: toolName },
     signal,
   });

package/dist/client/web-entry-gate-client.d.ts

@@ -1,34 +0,0 @@
-import type { Transport } from './transport';
-/**
- * Body for minting a web entry code (POST
- * `/api/channels/web/gates/{identity}/codes`). Both fields are optional-nullable
- * and sent EXPLICITLY: `label` is a human tag (`null` for none); `expires_at` is
- * an ISO-8601 instant the code dies at (`null` for a code that never expires).
- */
-export interface WebEntryCodeMintBody {
-    readonly label: string | null;
-    readonly expires_at: string | null;
-}
-export declare function webEntryGateClient(t: Transport): {
-    getWebEntryGate: (identity: string, signal?: AbortSignal) => Promise<{
-        enabled: boolean;
-        codes: {
-            code_id: string;
-            label: string | null;
-            created_at: string;
-            expires_at: string | null;
-        }[];
-    }>;
-    setWebEntryGate: (identity: string, enabled: boolean) => Promise<{
-        enabled: boolean;
-    }>;
-    mintWebEntryCode: (identity: string, body: WebEntryCodeMintBody) => Promise<{
-        code: string;
-        code_id: string;
-        expires_at: string | null;
-    }>;
-    revokeWebEntryCode: (identity: string, codeId: string) => Promise<{
-        status: "revoked";
-    }>;
-};
-//# sourceMappingURL=web-entry-gate-client.d.ts.map

package/dist/client/web-entry-gate-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"web-entry-gate-client.d.ts","sourceRoot":"","sources":["../../src/client/web-entry-gate-client.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;GAKG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS;gCAMf,MAAM,WAAW,WAAW;;;;;;;;;gCAE5B,MAAM,WAAW,OAAO;;;iCAOvB,MAAM,QAAQ,oBAAoB;;;;;mCAMhC,MAAM,UAAU,MAAM;;;EAOxD"}

package/dist/client/web-entry-gate-client.js

@@ -1,25 +0,0 @@
-/** Web-channel entry-gate sub-client. */
-import { encodeSegment } from '../http';
-import * as s from '../schemas';
-export function webEntryGateClient(t) {
-    const { req } = t;
-    return {
-        // A web route's entry gate, keyed by its `our_identity`: read the flag + its
-        // live codes, flip the flag, mint a code (raw returned ONCE), revoke a code by
-        // its hash id. The conversation monitor's first route mutations.
-        getWebEntryGate: (identity, signal) => req(`/api/channels/web/gates/${encodeSegment(identity)}`, s.webEntryGate, { signal }),
-        setWebEntryGate: (identity, enabled) => req(`/api/channels/web/gates/${encodeSegment(identity)}`, s.webEntryGateState, {
-            method: 'PUT',
-            body: { enabled },
-        }),
-        // Mint a code. `label`/`expires_at` are sent EXPLICITLY (including `null`). The
-        // raw `code` rides the reply ONCE (composed into the chat URL client-side).
-        mintWebEntryCode: (identity, body) => req(`/api/channels/web/gates/${encodeSegment(identity)}/codes`, s.webEntryCodeMinted, {
-            method: 'POST',
-            body: { label: body.label, expires_at: body.expires_at },
-        }),
-        // Revoke a code by its hash id (immediate + durable). 404 when the id is unknown.
-        revokeWebEntryCode: (identity, codeId) => req(`/api/channels/web/gates/${encodeSegment(identity)}/codes/${encodeSegment(codeId)}`, s.webEntryCodeRevoked, { method: 'DELETE' }),
-    };
-}
-//# sourceMappingURL=web-entry-gate-client.js.map

package/dist/client/web-entry-gate-client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"web-entry-gate-client.js","sourceRoot":"","sources":["../../src/client/web-entry-gate-client.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,KAAK,CAAC,MAAM,YAAY,CAAC;AAchC,MAAM,UAAU,kBAAkB,CAAC,CAAY;IAC7C,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;IAClB,OAAO;QACL,6EAA6E;QAC7E,+EAA+E;QAC/E,iEAAiE;QACjE,eAAe,EAAE,CAAC,QAAgB,EAAE,MAAoB,EAAE,EAAE,CAC1D,GAAG,CAAC,2BAA2B,aAAa,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,YAAY,EAAE,EAAE,MAAM,EAAE,CAAC;QACvF,eAAe,EAAE,CAAC,QAAgB,EAAE,OAAgB,EAAE,EAAE,CACtD,GAAG,CAAC,2BAA2B,aAAa,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,iBAAiB,EAAE;YAC7E,MAAM,EAAE,KAAK;YACb,IAAI,EAAE,EAAE,OAAO,EAAE;SAClB,CAAC;QACJ,gFAAgF;QAChF,4EAA4E;QAC5E,gBAAgB,EAAE,CAAC,QAAgB,EAAE,IAA0B,EAAE,EAAE,CACjE,GAAG,CAAC,2BAA2B,aAAa,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC,CAAC,kBAAkB,EAAE;YACpF,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE;SACzD,CAAC;QACJ,kFAAkF;QAClF,kBAAkB,EAAE,CAAC,QAAgB,EAAE,MAAc,EAAE,EAAE,CACvD,GAAG,CACD,2BAA2B,aAAa,CAAC,QAAQ,CAAC,UAAU,aAAa,CAAC,MAAM,CAAC,EAAE,EACnF,CAAC,CAAC,mBAAmB,EACrB,EAAE,MAAM,EAAE,QAAQ,EAAE,CACrB;KACJ,CAAC;AACJ,CAAC"}

package/dist/schemas/web-entry.d.ts

@@ -1,45 +0,0 @@
-/** Web-channel entry-gate code response schemas. */
-import { z } from 'zod';
-/** One minted entry code as the gate read door lists it — its hash id, its
- * optional label, and when it was created / dies. Never a raw code. */
-export declare const webEntryCode: z.ZodObject<{
-    code_id: z.ZodString;
-    label: z.ZodNullable<z.ZodString>;
-    created_at: z.ZodString;
-    expires_at: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type WebEntryCode = z.infer<typeof webEntryCode>;
-/** `GET /api/channels/web/gates/{identity}` — the gate flag and its live codes. */
-export declare const webEntryGate: z.ZodObject<{
-    enabled: z.ZodBoolean;
-    codes: z.ZodArray<z.ZodObject<{
-        code_id: z.ZodString;
-        label: z.ZodNullable<z.ZodString>;
-        created_at: z.ZodString;
-        expires_at: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type WebEntryGate = z.infer<typeof webEntryGate>;
-/** `PUT /api/channels/web/gates/{identity}` — the gate flag after the write. */
-export declare const webEntryGateState: z.ZodObject<{
-    enabled: z.ZodBoolean;
-}, z.core.$strip>;
-export type WebEntryGateState = z.infer<typeof webEntryGateState>;
-/**
- * `POST /api/channels/web/gates/{identity}/codes` — a freshly minted code. The
- * raw `code` rides this reply ONCE (nothing else stores or lists it — a listed
- * code's raw value is unrecoverable by design); `code_id` is its hash id and
- * `expires_at` an ISO-8601 instant, or `null` for a code that never expires.
- */
-export declare const webEntryCodeMinted: z.ZodObject<{
-    code: z.ZodString;
-    code_id: z.ZodString;
-    expires_at: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type WebEntryCodeMinted = z.infer<typeof webEntryCodeMinted>;
-/** `DELETE /api/channels/web/gates/{identity}/codes/{code_id}` — the revoked code. */
-export declare const webEntryCodeRevoked: z.ZodObject<{
-    status: z.ZodLiteral<"revoked">;
-}, z.core.$strip>;
-export type WebEntryCodeRevoked = z.infer<typeof webEntryCodeRevoked>;
-//# sourceMappingURL=web-entry.d.ts.map

package/dist/schemas/web-entry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"web-entry.d.ts","sourceRoot":"","sources":["../../src/schemas/web-entry.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB;uEACuE;AACvE,eAAO,MAAM,YAAY;;;;;iBAKvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,mFAAmF;AACnF,eAAO,MAAM,YAAY;;;;;;;;iBAGvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,gFAAgF;AAChF,eAAO,MAAM,iBAAiB;;iBAAqC,CAAC;AACpE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE,sFAAsF;AACtF,eAAO,MAAM,mBAAmB;;iBAA6C,CAAC;AAC9E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/schemas/web-entry.js

@@ -1,36 +0,0 @@
-/** Web-channel entry-gate code response schemas. */
-import { z } from 'zod';
-// The web channel's entry gate: a web route can be gated so its chat page is
-// served only to a navigation carrying a live entry code. These four doors are
-// keyed by the route's `our_identity`. A raw code exists only in flight (the
-// mint reply); a listed code carries its hash id, never a raw value (none is
-// stored).
-/** One minted entry code as the gate read door lists it — its hash id, its
- * optional label, and when it was created / dies. Never a raw code. */
-export const webEntryCode = z.object({
-    code_id: z.string(),
-    label: z.string().nullable(),
-    created_at: z.string(),
-    expires_at: z.string().nullable(),
-});
-/** `GET /api/channels/web/gates/{identity}` — the gate flag and its live codes. */
-export const webEntryGate = z.object({
-    enabled: z.boolean(),
-    codes: z.array(webEntryCode),
-});
-/** `PUT /api/channels/web/gates/{identity}` — the gate flag after the write. */
-export const webEntryGateState = z.object({ enabled: z.boolean() });
-/**
- * `POST /api/channels/web/gates/{identity}/codes` — a freshly minted code. The
- * raw `code` rides this reply ONCE (nothing else stores or lists it — a listed
- * code's raw value is unrecoverable by design); `code_id` is its hash id and
- * `expires_at` an ISO-8601 instant, or `null` for a code that never expires.
- */
-export const webEntryCodeMinted = z.object({
-    code: z.string(),
-    code_id: z.string(),
-    expires_at: z.string().nullable(),
-});
-/** `DELETE /api/channels/web/gates/{identity}/codes/{code_id}` — the revoked code. */
-export const webEntryCodeRevoked = z.object({ status: z.literal('revoked') });
-//# sourceMappingURL=web-entry.js.map

package/dist/schemas/web-entry.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"web-entry.js","sourceRoot":"","sources":["../../src/schemas/web-entry.ts"],"names":[],"mappings":"AAAA,oDAAoD;AACpD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,6EAA6E;AAC7E,+EAA+E;AAC/E,6EAA6E;AAC7E,6EAA6E;AAC7E,WAAW;AAEX;uEACuE;AACvE,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC5B,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE;IACtB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC,CAAC;AAGH,mFAAmF;AACnF,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,CAAC,MAAM,CAAC;IACnC,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE;IACpB,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC;CAC7B,CAAC,CAAC;AAGH,gFAAgF;AAChF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;AAGpE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE;IAChB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,UAAU,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAClC,CAAC,CAAC;AAGH,sFAAsF;AACtF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC"}

package/src/client/web-entry-gate-client.ts

@@ -1,45 +0,0 @@
-/** Web-channel entry-gate sub-client. */
-import { encodeSegment } from '../http';
-import * as s from '../schemas';
-import type { Transport } from './transport';
-
-/**
- * Body for minting a web entry code (POST
- * `/api/channels/web/gates/{identity}/codes`). Both fields are optional-nullable
- * and sent EXPLICITLY: `label` is a human tag (`null` for none); `expires_at` is
- * an ISO-8601 instant the code dies at (`null` for a code that never expires).
- */
-export interface WebEntryCodeMintBody {
-  readonly label: string | null;
-  readonly expires_at: string | null;
-}
-
-export function webEntryGateClient(t: Transport) {
-  const { req } = t;
-  return {
-    // A web route's entry gate, keyed by its `our_identity`: read the flag + its
-    // live codes, flip the flag, mint a code (raw returned ONCE), revoke a code by
-    // its hash id. The conversation monitor's first route mutations.
-    getWebEntryGate: (identity: string, signal?: AbortSignal) =>
-      req(`/api/channels/web/gates/${encodeSegment(identity)}`, s.webEntryGate, { signal }),
-    setWebEntryGate: (identity: string, enabled: boolean) =>
-      req(`/api/channels/web/gates/${encodeSegment(identity)}`, s.webEntryGateState, {
-        method: 'PUT',
-        body: { enabled },
-      }),
-    // Mint a code. `label`/`expires_at` are sent EXPLICITLY (including `null`). The
-    // raw `code` rides the reply ONCE (composed into the chat URL client-side).
-    mintWebEntryCode: (identity: string, body: WebEntryCodeMintBody) =>
-      req(`/api/channels/web/gates/${encodeSegment(identity)}/codes`, s.webEntryCodeMinted, {
-        method: 'POST',
-        body: { label: body.label, expires_at: body.expires_at },
-      }),
-    // Revoke a code by its hash id (immediate + durable). 404 when the id is unknown.
-    revokeWebEntryCode: (identity: string, codeId: string) =>
-      req(
-        `/api/channels/web/gates/${encodeSegment(identity)}/codes/${encodeSegment(codeId)}`,
-        s.webEntryCodeRevoked,
-        { method: 'DELETE' },
-      ),
-  };
-}

package/src/schemas/web-entry.ts

@@ -1,46 +0,0 @@
-/** Web-channel entry-gate code response schemas. */
-import { z } from 'zod';
-
-// The web channel's entry gate: a web route can be gated so its chat page is
-// served only to a navigation carrying a live entry code. These four doors are
-// keyed by the route's `our_identity`. A raw code exists only in flight (the
-// mint reply); a listed code carries its hash id, never a raw value (none is
-// stored).
-
-/** One minted entry code as the gate read door lists it — its hash id, its
- * optional label, and when it was created / dies. Never a raw code. */
-export const webEntryCode = z.object({
-  code_id: z.string(),
-  label: z.string().nullable(),
-  created_at: z.string(),
-  expires_at: z.string().nullable(),
-});
-export type WebEntryCode = z.infer<typeof webEntryCode>;
-
-/** `GET /api/channels/web/gates/{identity}` — the gate flag and its live codes. */
-export const webEntryGate = z.object({
-  enabled: z.boolean(),
-  codes: z.array(webEntryCode),
-});
-export type WebEntryGate = z.infer<typeof webEntryGate>;
-
-/** `PUT /api/channels/web/gates/{identity}` — the gate flag after the write. */
-export const webEntryGateState = z.object({ enabled: z.boolean() });
-export type WebEntryGateState = z.infer<typeof webEntryGateState>;
-
-/**
- * `POST /api/channels/web/gates/{identity}/codes` — a freshly minted code. The
- * raw `code` rides this reply ONCE (nothing else stores or lists it — a listed
- * code's raw value is unrecoverable by design); `code_id` is its hash id and
- * `expires_at` an ISO-8601 instant, or `null` for a code that never expires.
- */
-export const webEntryCodeMinted = z.object({
-  code: z.string(),
-  code_id: z.string(),
-  expires_at: z.string().nullable(),
-});
-export type WebEntryCodeMinted = z.infer<typeof webEntryCodeMinted>;
-
-/** `DELETE /api/channels/web/gates/{identity}/codes/{code_id}` — the revoked code. */
-export const webEntryCodeRevoked = z.object({ status: z.literal('revoked') });
-export type WebEntryCodeRevoked = z.infer<typeof webEntryCodeRevoked>;