@ggui-ai/protocol 0.1.0-rc.1

package/dist/schemas/gadget-name-grammar.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Gadget export-name grammars — leaf module, ZERO imports.
+ *
+ * The `use`-prefixed hook grammar and the PascalCase component
+ * grammar are needed by both `schemas/data-contract.ts` (wire
+ * schemas) and `validation/hygiene-rules.ts` (catalog lints).
+ * `data-contract.ts` already imports `KNOWN_PERMISSION_NAMES` from
+ * `hygiene-rules.ts`; having `hygiene-rules.ts` import the regexes
+ * back from `data-contract.ts` would close an import cycle. Pinning
+ * the two grammars in this dependency-free leaf keeps both consumers
+ * importing downward only — no cycle is possible.
+ *
+ * `data-contract.ts` re-exports both symbols, so the package barrel
+ * (`index.ts`) surface is unchanged for external consumers.
+ */
+/**
+ * Hook-name grammar — `use`-prefixed camelCase (`useLeafletMap`,
+ * `useGeolocation`). Formalizes the convention the boilerplate
+ * generator + the LLM rely on. Excludes tab so `gadgetIdentityKey`
+ * cannot collide.
+ */
+export declare const HOOK_NAME_RE: RegExp;
+/**
+ * Component-name grammar — PascalCase (`Chart`, `MapView`). A gadget
+ * component export is rendered as JSX, so the name must be a legal
+ * PascalCase React component identifier.
+ */
+export declare const COMPONENT_NAME_RE: RegExp;
+//# sourceMappingURL=gadget-name-grammar.d.ts.map

package/dist/schemas/gadget-name-grammar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gadget-name-grammar.d.ts","sourceRoot":"","sources":["../../src/schemas/gadget-name-grammar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,YAAY,QAA2B,CAAC;AAErD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,QAAwB,CAAC"}

package/dist/schemas/gadget-name-grammar.js

@@ -0,0 +1,28 @@
+/**
+ * Gadget export-name grammars — leaf module, ZERO imports.
+ *
+ * The `use`-prefixed hook grammar and the PascalCase component
+ * grammar are needed by both `schemas/data-contract.ts` (wire
+ * schemas) and `validation/hygiene-rules.ts` (catalog lints).
+ * `data-contract.ts` already imports `KNOWN_PERMISSION_NAMES` from
+ * `hygiene-rules.ts`; having `hygiene-rules.ts` import the regexes
+ * back from `data-contract.ts` would close an import cycle. Pinning
+ * the two grammars in this dependency-free leaf keeps both consumers
+ * importing downward only — no cycle is possible.
+ *
+ * `data-contract.ts` re-exports both symbols, so the package barrel
+ * (`index.ts`) surface is unchanged for external consumers.
+ */
+/**
+ * Hook-name grammar — `use`-prefixed camelCase (`useLeafletMap`,
+ * `useGeolocation`). Formalizes the convention the boilerplate
+ * generator + the LLM rely on. Excludes tab so `gadgetIdentityKey`
+ * cannot collide.
+ */
+export const HOOK_NAME_RE = /^use[A-Z][A-Za-z0-9]*$/;
+/**
+ * Component-name grammar — PascalCase (`Chart`, `MapView`). A gadget
+ * component export is rendered as JSX, so the name must be a legal
+ * PascalCase React component identifier.
+ */
+export const COMPONENT_NAME_RE = /^[A-Z][A-Za-z0-9]*$/;

package/dist/schemas/handshake-suggestion.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Zod mirrors for the handshake-suggestion shapes
+ * (`packages/protocol/src/types/handshake-suggestion.ts`).
+ *
+ * Structural-mirror discipline matches `data-contract.ts` /
+ * `blueprint.ts`: TS interfaces in `../types/handshake-suggestion.ts`
+ * are the declared source of truth; the schemas here are typed
+ * `z.ZodType<T>` so any drift fails compile.
+ */
+import { z } from 'zod';
+import type { BlueprintDraft, BlueprintMeta, HandshakeSuggestion, JsonPatch, JsonPatchOp, PushDecision, SuggestionAmendments, SuggestionFinding, SuggestionOrigin } from '../types/handshake-suggestion.js';
+/** Three-mode routing enum on {@link HandshakeSuggestion.origin}. */
+export declare const suggestionOriginSchema: z.ZodType<SuggestionOrigin>;
+/** Single JSON-Patch op (RFC 6902 subset — add/remove/replace). */
+export declare const jsonPatchOpSchema: z.ZodType<JsonPatchOp>;
+/** `JsonPatch` — array of ops; subset support per the doc. */
+export declare const jsonPatchSchema: z.ZodType<JsonPatch>;
+/**
+ * Inner zod-object form of {@link blueprintDraftSchema}. Exposed so
+ * the sync-check script can reflect `.shape` to enumerate fields;
+ * normal consumers should prefer {@link blueprintDraftSchema} (typed
+ * `z.ZodType<BlueprintDraft>`).
+ */
+export declare const blueprintDraftObjectSchema: z.ZodObject<{
+    contract: z.ZodType<import("../index.js").DataContract, unknown, z.core.$ZodTypeInternals<import("../index.js").DataContract, unknown>>;
+    variance: z.ZodOptional<z.ZodObject<{
+        persona: z.ZodOptional<z.ZodString>;
+        aesthetic: z.ZodOptional<z.ZodString>;
+        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>>;
+        seedPrompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    generator: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** `BlueprintDraft` — input shape on handshake + override push. */
+export declare const blueprintDraftSchema: z.ZodType<BlueprintDraft>;
+/** `BlueprintMeta` — projected onto the handshake response. */
+export declare const blueprintMetaSchema: z.ZodType<BlueprintMeta>;
+/** `SuggestionFinding` — validator finding surfaced on the suggestion. */
+export declare const suggestionFindingSchema: z.ZodType<SuggestionFinding>;
+/** Synth amendment — JSON-Patch diff + reasoning. */
+export declare const suggestionAmendmentsSchema: z.ZodType<SuggestionAmendments>;
+/** The full handshake suggestion — produced in step-2 of the handshake. */
+export declare const handshakeSuggestionSchema: z.ZodType<HandshakeSuggestion>;
+/** Push decision discriminator — accept vs override. */
+export declare const pushDecisionSchema: z.ZodType<PushDecision>;
+//# sourceMappingURL=handshake-suggestion.d.ts.map

package/dist/schemas/handshake-suggestion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handshake-suggestion.d.ts","sourceRoot":"","sources":["../../src/schemas/handshake-suggestion.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,SAAS,EACT,WAAW,EACX,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,kCAAkC,CAAC;AAI1C,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAI7D,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAezB,CAAC;AAE7B,8DAA8D;AAC9D,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAsD,CAAC;AAExG;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;kBAc5B,CAAC;AAEZ,mEAAmE;AACnE,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAA2D,CAAC;AAEvH,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CASlB,CAAC;AAExC,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAOtB,CAAC;AAE5C,qDAAqD;AACrD,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAKzB,CAAC;AAE/C,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAQxB,CAAC;AAE9C,wDAAwD;AACxD,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAQ1B,CAAC"}

package/dist/schemas/handshake-suggestion.js

@@ -0,0 +1,107 @@
+/**
+ * Zod mirrors for the handshake-suggestion shapes
+ * (`packages/protocol/src/types/handshake-suggestion.ts`).
+ *
+ * Structural-mirror discipline matches `data-contract.ts` /
+ * `blueprint.ts`: TS interfaces in `../types/handshake-suggestion.ts`
+ * are the declared source of truth; the schemas here are typed
+ * `z.ZodType<T>` so any drift fails compile.
+ */
+import { z } from 'zod';
+import { dataContractSchema, jsonValueSchema } from './data-contract.js';
+import { blueprintVarianceSchema } from './blueprint.js';
+/** Three-mode routing enum on {@link HandshakeSuggestion.origin}. */
+export const suggestionOriginSchema = z.enum([
+    'cache',
+    'agent',
+    'synth',
+]);
+/** Single JSON-Patch op (RFC 6902 subset — add/remove/replace). */
+export const jsonPatchOpSchema = z.union([
+    z.object({
+        op: z.literal('add'),
+        path: z.string(),
+        value: jsonValueSchema,
+    }).strict(),
+    z.object({
+        op: z.literal('remove'),
+        path: z.string(),
+    }).strict(),
+    z.object({
+        op: z.literal('replace'),
+        path: z.string(),
+        value: jsonValueSchema,
+    }).strict(),
+]);
+/** `JsonPatch` — array of ops; subset support per the doc. */
+export const jsonPatchSchema = z.array(jsonPatchOpSchema);
+/**
+ * Inner zod-object form of {@link blueprintDraftSchema}. Exposed so
+ * the sync-check script can reflect `.shape` to enumerate fields;
+ * normal consumers should prefer {@link blueprintDraftSchema} (typed
+ * `z.ZodType<BlueprintDraft>`).
+ */
+export const blueprintDraftObjectSchema = z
+    .object({
+    contract: dataContractSchema,
+    variance: z
+        .object({
+        persona: z.string().optional(),
+        aesthetic: z.string().optional(),
+        context: z.record(z.string(), jsonValueSchema).optional(),
+        seedPrompt: z.string().optional(),
+    })
+        .strict()
+        .optional(),
+    generator: z.string().optional(),
+})
+    .strict();
+/** `BlueprintDraft` — input shape on handshake + override push. */
+export const blueprintDraftSchema = blueprintDraftObjectSchema;
+/** `BlueprintMeta` — projected onto the handshake response. */
+export const blueprintMetaSchema = z
+    .object({
+    blueprintId: z.string().min(1),
+    contractHash: z.string().min(1),
+    codeHash: z.string().optional(),
+    generator: z.string().min(1),
+    variance: blueprintVarianceSchema,
+    selectedReason: z.string().optional(),
+})
+    .strict();
+/** `SuggestionFinding` — validator finding surfaced on the suggestion. */
+export const suggestionFindingSchema = z
+    .object({
+    code: z.string().min(1),
+    severity: z.enum(['error', 'warn']),
+    path: z.string(),
+    message: z.string(),
+})
+    .strict();
+/** Synth amendment — JSON-Patch diff + reasoning. */
+export const suggestionAmendmentsSchema = z
+    .object({
+    contractDiff: jsonPatchSchema,
+    reasoning: z.string(),
+})
+    .strict();
+/** The full handshake suggestion — produced in step-2 of the handshake. */
+export const handshakeSuggestionSchema = z
+    .object({
+    origin: suggestionOriginSchema,
+    rationale: z.string(),
+    blueprintMeta: blueprintMetaSchema,
+    amendments: suggestionAmendmentsSchema.optional(),
+    validationFindings: z.array(suggestionFindingSchema).optional(),
+})
+    .strict();
+/** Push decision discriminator — accept vs override. */
+export const pushDecisionSchema = z.union([
+    z.object({ kind: z.literal('accept') }).strict(),
+    z
+        .object({
+        kind: z.literal('override'),
+        blueprintDraft: blueprintDraftSchema,
+    })
+        .strict(),
+]);

package/dist/schemas/invoke.d.ts

@@ -0,0 +1,337 @@
+/**
+ * Streamable Invoke Protocol v1 — Zod schemas.
+ *
+ * Single source of truth for the client→agent invoke turn. Mirrors Anthropic's
+ * Messages streaming format exactly (message_start / content_block_{start,delta,stop}
+ * / message_delta / message_stop / ping / error). UI rendering is expressed as
+ * plain `tool_use` blocks calling the `ggui_render` / `ggui_render_blueprint`
+ * client tools — no ggui-specific block type.
+ *
+ * TS types in types/invoke.ts are derived from these via z.infer. Consumers
+ * (@ggui-ai/server, @ggui-ai/react) import schemas for runtime validation
+ * and types for authoring.
+ */
+import { z } from 'zod';
+/** Plain text content — streamed via `text_delta` events. */
+export declare const textBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>;
+/** Tool call initiated by the agent. Input may arrive via `input_json_delta`. */
+export declare const toolUseBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+/**
+ * Tool execution result (Protocol v1.1).
+ *
+ * Emitted inline on the assistant turn when the server executed a tool on
+ * the agent's behalf (e.g. `ggui_push`, `ggui_handshake`). Clients pair this
+ * with the matching `tool_use` by `tool_use_id` and render — no second
+ * round-trip through a `ggui_render` client tool is needed.
+ *
+ * This extends Anthropic's shape: Anthropic puts `tool_result` in the next
+ * user message, we also allow it on the assistant turn because the server
+ * already has the result. The `content` shape depends on the tool.
+ */
+export declare const toolResultBlockSchema: z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    tool_use_id: z.ZodString;
+    content: z.ZodUnknown;
+    is_error: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/** Discriminated union of every legal content block type. */
+export declare const contentBlockSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_use">;
+    id: z.ZodString;
+    name: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"tool_result">;
+    tool_use_id: z.ZodString;
+    content: z.ZodUnknown;
+    is_error: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>], "type">;
+export declare const textDeltaSchema: z.ZodObject<{
+    type: z.ZodLiteral<"text_delta">;
+    text: z.ZodString;
+}, z.core.$strip>;
+export declare const inputJsonDeltaSchema: z.ZodObject<{
+    type: z.ZodLiteral<"input_json_delta">;
+    partial_json: z.ZodString;
+}, z.core.$strip>;
+export declare const contentBlockDeltaPayloadSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"text_delta">;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"input_json_delta">;
+    partial_json: z.ZodString;
+}, z.core.$strip>], "type">;
+/** First event of a turn. */
+export declare const messageStartEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"message_start">;
+    message: z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodLiteral<"assistant">;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** A new content block begins. */
+export declare const contentBlockStartEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"content_block_start">;
+    index: z.ZodNumber;
+    content_block: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        tool_use_id: z.ZodString;
+        content: z.ZodUnknown;
+        is_error: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+/** Incremental update to the block at `index`. */
+export declare const contentBlockDeltaEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"content_block_delta">;
+    index: z.ZodNumber;
+    delta: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text_delta">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"input_json_delta">;
+        partial_json: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>;
+/** The block at `index` is complete. */
+export declare const contentBlockStopEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"content_block_stop">;
+    index: z.ZodNumber;
+}, z.core.$strip>;
+/** Final metadata just before the turn ends. */
+export declare const messageDeltaEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"message_delta">;
+    delta: z.ZodObject<{
+        stop_reason: z.ZodEnum<{
+            error: "error";
+            tool_use: "tool_use";
+            end_turn: "end_turn";
+            max_tokens: "max_tokens";
+        }>;
+        stop_sequence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/** Turn is done. No events may follow. */
+export declare const messageStopEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"message_stop">;
+}, z.core.$strip>;
+/** Keep-alive frame. */
+export declare const pingEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+}, z.core.$strip>;
+/** Terminal error. No `message_stop` follows. */
+export declare const invokeErrorCodeSchema: z.ZodEnum<{
+    invalid_request: "invalid_request";
+    unauthorized: "unauthorized";
+    rate_limited: "rate_limited";
+    invoke_in_progress: "invoke_in_progress";
+    upstream_error: "upstream_error";
+    tool_error: "tool_error";
+    internal: "internal";
+}>;
+export declare const errorEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            invalid_request: "invalid_request";
+            unauthorized: "unauthorized";
+            rate_limited: "rate_limited";
+            invoke_in_progress: "invoke_in_progress";
+            upstream_error: "upstream_error";
+            tool_error: "tool_error";
+            internal: "internal";
+        }>;
+        message: z.ZodString;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+/**
+ * Discriminated union over every event the agent may emit.
+ *
+ * Parsing an incoming SSE frame:
+ *   const event = invokeEventSchema.parse(JSON.parse(frame.data));
+ *   switch (event.type) { ... }
+ */
+export declare const invokeEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"message_start">;
+    message: z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodLiteral<"assistant">;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"content_block_start">;
+    index: z.ZodNumber;
+    content_block: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        tool_use_id: z.ZodString;
+        content: z.ZodUnknown;
+        is_error: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"content_block_delta">;
+    index: z.ZodNumber;
+    delta: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text_delta">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"input_json_delta">;
+        partial_json: z.ZodString;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"content_block_stop">;
+    index: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"message_delta">;
+    delta: z.ZodObject<{
+        stop_reason: z.ZodEnum<{
+            error: "error";
+            tool_use: "tool_use";
+            end_turn: "end_turn";
+            max_tokens: "max_tokens";
+        }>;
+        stop_sequence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strip>;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"message_stop">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"ping">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        code: z.ZodEnum<{
+            invalid_request: "invalid_request";
+            unauthorized: "unauthorized";
+            rate_limited: "rate_limited";
+            invoke_in_progress: "invoke_in_progress";
+            upstream_error: "upstream_error";
+            tool_error: "tool_error";
+            internal: "internal";
+        }>;
+        message: z.ZodString;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+/**
+ * A prior conversation turn. Content is either a plain text shortcut or a
+ * structured content block sequence (mirrors Anthropic's `messages[].content`).
+ */
+export declare const invokeTurnSchema: z.ZodObject<{
+    role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+    }>;
+    content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_use">;
+        id: z.ZodString;
+        name: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"tool_result">;
+        tool_use_id: z.ZodString;
+        content: z.ZodUnknown;
+        is_error: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "type">>]>;
+}, z.core.$strip>;
+/**
+ * POST body shape for `{endpointUrl}/invoke`.
+ *
+ * Stateless by default — client holds history, sends full `history[]` every
+ * turn. Agents that need server-side memory layer their own keyed on
+ * `X-Ggui-Session-Id`.
+ */
+export declare const invokeRequestSchema: z.ZodObject<{
+    message: z.ZodString;
+    history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+        }>;
+        content: z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_use">;
+            id: z.ZodString;
+            name: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_result">;
+            tool_use_id: z.ZodString;
+            content: z.ZodUnknown;
+            is_error: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>], "type">>]>;
+    }, z.core.$strip>>>;
+    interfaceContext: z.ZodOptional<z.ZodObject<{
+        viewport: z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>;
+        platform: z.ZodEnum<{
+            web: "web";
+            desktop: "desktop";
+            mobile: "mobile";
+        }>;
+        deviceType: z.ZodEnum<{
+            desktop: "desktop";
+            phone: "phone";
+            tablet: "tablet";
+        }>;
+        orientation: z.ZodEnum<{
+            portrait: "portrait";
+            landscape: "landscape";
+        }>;
+        devicePixelRatio: z.ZodOptional<z.ZodNumber>;
+        touchPrimary: z.ZodOptional<z.ZodBoolean>;
+        shellType: z.ZodOptional<z.ZodEnum<{
+            fullscreen: "fullscreen";
+            chat: "chat";
+            spatial: "spatial";
+        }>>;
+        colorScheme: z.ZodOptional<z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+        }>>;
+        reducedMotion: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=invoke.d.ts.map

package/dist/schemas/invoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.d.ts","sourceRoot":"","sources":["../../src/schemas/invoke.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,6DAA6D;AAC7D,eAAO,MAAM,eAAe;;;iBAG1B,CAAC;AAEH,iFAAiF;AACjF,eAAO,MAAM,kBAAkB;;;;;iBAK7B,CAAC;AAEH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB;;;;;iBAKhC,CAAC;AAEH,6DAA6D;AAC7D,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;2BAI7B,CAAC;AAIH,eAAO,MAAM,eAAe;;;iBAG1B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;iBAG/B,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;2BAGzC,CAAC;AAIH,6BAA6B;AAC7B,eAAO,MAAM,uBAAuB;;;;;;;iBAOlC,CAAC;AAEH,kCAAkC;AAClC,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;iBAIvC,CAAC;AAEH,kDAAkD;AAClD,eAAO,MAAM,4BAA4B;;;;;;;;;;iBAIvC,CAAC;AAEH,wCAAwC;AACxC,eAAO,MAAM,2BAA2B;;;iBAGtC,CAAC;AAEH,gDAAgD;AAChD,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;iBAUlC,CAAC;AAEH,0CAA0C;AAC1C,eAAO,MAAM,sBAAsB;;iBAEjC,CAAC;AAEH,wBAAwB;AACxB,eAAO,MAAM,eAAe;;iBAE1B,CAAC;AAEH,iDAAiD;AACjD,eAAO,MAAM,qBAAqB;;;;;;;;EAQhC,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;iBAO3B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAS5B,CAAC;AAIH;;;GAGG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;iBAG3B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAK9B,CAAC"}