@kb-labs/gateway-contracts 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,1645 @@
+import { z } from 'zod';
+
+declare const UpstreamConfigSchema: z.ZodObject<{
+    url: z.ZodString;
+    prefix: z.ZodString;
+    /** Strip prefix before forwarding. Default: keep prefix as-is. Use "" to strip. */
+    rewritePrefix: z.ZodOptional<z.ZodString>;
+    /** Enable WebSocket proxying for this upstream. Default: false. */
+    websocket: z.ZodOptional<z.ZodBoolean>;
+    /** Paths under this prefix that are NOT proxied (handled by gateway itself). */
+    excludePaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    prefix: string;
+    rewritePrefix?: string | undefined;
+    websocket?: boolean | undefined;
+    excludePaths?: string[] | undefined;
+    description?: string | undefined;
+}, {
+    url: string;
+    prefix: string;
+    rewritePrefix?: string | undefined;
+    websocket?: boolean | undefined;
+    excludePaths?: string[] | undefined;
+    description?: string | undefined;
+}>;
+declare const StaticTokenEntrySchema: z.ZodObject<{
+    hostId: z.ZodString;
+    namespaceId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    hostId: string;
+    namespaceId: string;
+}, {
+    hostId: string;
+    namespaceId: string;
+}>;
+declare const GatewayConfigSchema: z.ZodObject<{
+    port: z.ZodDefault<z.ZodNumber>;
+    upstreams: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        url: z.ZodString;
+        prefix: z.ZodString;
+        /** Strip prefix before forwarding. Default: keep prefix as-is. Use "" to strip. */
+        rewritePrefix: z.ZodOptional<z.ZodString>;
+        /** Enable WebSocket proxying for this upstream. Default: false. */
+        websocket: z.ZodOptional<z.ZodBoolean>;
+        /** Paths under this prefix that are NOT proxied (handled by gateway itself). */
+        excludePaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        prefix: string;
+        rewritePrefix?: string | undefined;
+        websocket?: boolean | undefined;
+        excludePaths?: string[] | undefined;
+        description?: string | undefined;
+    }, {
+        url: string;
+        prefix: string;
+        rewritePrefix?: string | undefined;
+        websocket?: boolean | undefined;
+        excludePaths?: string[] | undefined;
+        description?: string | undefined;
+    }>>>;
+    /** Static tokens seeded into ICache at bootstrap — for dev/service tokens before full auth */
+    staticTokens: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodObject<{
+        hostId: z.ZodString;
+        namespaceId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        hostId: string;
+        namespaceId: string;
+    }, {
+        hostId: string;
+        namespaceId: string;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    port: number;
+    upstreams: Record<string, {
+        url: string;
+        prefix: string;
+        rewritePrefix?: string | undefined;
+        websocket?: boolean | undefined;
+        excludePaths?: string[] | undefined;
+        description?: string | undefined;
+    }>;
+    staticTokens: Record<string, {
+        hostId: string;
+        namespaceId: string;
+    }>;
+}, {
+    port?: number | undefined;
+    upstreams?: Record<string, {
+        url: string;
+        prefix: string;
+        rewritePrefix?: string | undefined;
+        websocket?: boolean | undefined;
+        excludePaths?: string[] | undefined;
+        description?: string | undefined;
+    }> | undefined;
+    staticTokens?: Record<string, {
+        hostId: string;
+        namespaceId: string;
+    }> | undefined;
+}>;
+type UpstreamConfig = z.infer<typeof UpstreamConfigSchema>;
+type GatewayConfig = z.infer<typeof GatewayConfigSchema>;
+
+declare const HostCapabilitySchema: z.ZodEnum<["filesystem", "git", "editor-context", "execution"]>;
+declare const HostTypeSchema: z.ZodEnum<["local", "cloud"]>;
+declare const HostRegistrationSchema: z.ZodObject<{
+    name: z.ZodString;
+    namespaceId: z.ZodString;
+    capabilities: z.ZodArray<z.ZodEnum<["filesystem", "git", "editor-context", "execution"]>, "many">;
+    workspacePaths: z.ZodArray<z.ZodString, "many">;
+    hostType: z.ZodOptional<z.ZodEnum<["local", "cloud"]>>;
+}, "strip", z.ZodTypeAny, {
+    namespaceId: string;
+    capabilities: ("filesystem" | "git" | "editor-context" | "execution")[];
+    name: string;
+    workspacePaths: string[];
+    hostType?: "local" | "cloud" | undefined;
+}, {
+    namespaceId: string;
+    capabilities: ("filesystem" | "git" | "editor-context" | "execution")[];
+    name: string;
+    workspacePaths: string[];
+    hostType?: "local" | "cloud" | undefined;
+}>;
+declare const HostStatusSchema: z.ZodEnum<["online", "offline", "degraded", "reconnecting"]>;
+declare const HostDescriptorSchema: z.ZodObject<{
+    hostId: z.ZodString;
+    name: z.ZodString;
+    namespaceId: z.ZodString;
+    capabilities: z.ZodArray<z.ZodEnum<["filesystem", "git", "editor-context", "execution"]>, "many">;
+    status: z.ZodEnum<["online", "offline", "degraded", "reconnecting"]>;
+    lastSeen: z.ZodNumber;
+    connections: z.ZodArray<z.ZodString, "many">;
+    hostType: z.ZodOptional<z.ZodEnum<["local", "cloud"]>>;
+    workspaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        workspaceId: z.ZodString;
+        repoFingerprint: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        workspaceId: string;
+        repoFingerprint?: string | undefined;
+        branch?: string | undefined;
+    }, {
+        workspaceId: string;
+        repoFingerprint?: string | undefined;
+        branch?: string | undefined;
+    }>, "many">>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        version: string;
+    }, {
+        id: string;
+        version: string;
+    }>, "many">>;
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    updatedAt: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    status: "online" | "offline" | "degraded" | "reconnecting";
+    hostId: string;
+    namespaceId: string;
+    capabilities: ("filesystem" | "git" | "editor-context" | "execution")[];
+    name: string;
+    lastSeen: number;
+    connections: string[];
+    hostType?: "local" | "cloud" | undefined;
+    workspaces?: {
+        workspaceId: string;
+        repoFingerprint?: string | undefined;
+        branch?: string | undefined;
+    }[] | undefined;
+    plugins?: {
+        id: string;
+        version: string;
+    }[] | undefined;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+}, {
+    status: "online" | "offline" | "degraded" | "reconnecting";
+    hostId: string;
+    namespaceId: string;
+    capabilities: ("filesystem" | "git" | "editor-context" | "execution")[];
+    name: string;
+    lastSeen: number;
+    connections: string[];
+    hostType?: "local" | "cloud" | undefined;
+    workspaces?: {
+        workspaceId: string;
+        repoFingerprint?: string | undefined;
+        branch?: string | undefined;
+    }[] | undefined;
+    plugins?: {
+        id: string;
+        version: string;
+    }[] | undefined;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+}>;
+declare const HostRegisterResponseSchema: z.ZodObject<{
+    hostId: z.ZodString;
+    machineToken: z.ZodString;
+    status: z.ZodEnum<["online", "offline", "degraded", "reconnecting"]>;
+}, "strip", z.ZodTypeAny, {
+    status: "online" | "offline" | "degraded" | "reconnecting";
+    hostId: string;
+    machineToken: string;
+}, {
+    status: "online" | "offline" | "degraded" | "reconnecting";
+    hostId: string;
+    machineToken: string;
+}>;
+type HostStatus = z.infer<typeof HostStatusSchema>;
+type HostCapability = z.infer<typeof HostCapabilitySchema>;
+type HostType = z.infer<typeof HostTypeSchema>;
+type HostRegistration = z.infer<typeof HostRegistrationSchema>;
+type HostDescriptor = z.infer<typeof HostDescriptorSchema>;
+type HostRegisterResponse = z.infer<typeof HostRegisterResponseSchema>;
+/**
+ * Durable host storage abstraction.
+ *
+ * Implementations persist host descriptors and tokens across restarts.
+ * The registry uses this as the "cold" layer while ICache serves as "hot" layer.
+ */
+interface IHostStore {
+    /** Persist or update a host descriptor. */
+    save(descriptor: HostDescriptor): Promise<void>;
+    /** Retrieve a host by id + namespace. */
+    get(hostId: string, namespaceId: string): Promise<HostDescriptor | null>;
+    /** List all hosts in a namespace. */
+    list(namespaceId: string): Promise<HostDescriptor[]>;
+    /** List all hosts across all namespaces. */
+    listAll(): Promise<HostDescriptor[]>;
+    /** Remove a host. Returns true if it existed. */
+    delete(hostId: string, namespaceId: string): Promise<boolean>;
+    /** Persist a machine token → host mapping. */
+    saveToken(token: string, hostId: string, namespaceId: string): Promise<void>;
+    /** Resolve a machine token to its host. */
+    resolveToken(token: string): Promise<{
+        hostId: string;
+        namespaceId: string;
+    } | null>;
+    /** Remove a machine token. */
+    deleteToken(token: string): Promise<void>;
+}
+
+declare const TokenTypeSchema: z.ZodEnum<["user", "cli", "machine"]>;
+declare const AuthContextSchema: z.ZodObject<{
+    type: z.ZodEnum<["user", "cli", "machine"]>;
+    userId: z.ZodString;
+    namespaceId: z.ZodString;
+    tier: z.ZodEnum<["free", "pro", "enterprise"]>;
+    permissions: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "user" | "cli" | "machine";
+    namespaceId: string;
+    userId: string;
+    tier: "free" | "pro" | "enterprise";
+    permissions: string[];
+}, {
+    type: "user" | "cli" | "machine";
+    namespaceId: string;
+    userId: string;
+    tier: "free" | "pro" | "enterprise";
+    permissions: string[];
+}>;
+type TokenType = z.infer<typeof TokenTypeSchema>;
+type AuthContext = z.infer<typeof AuthContextSchema>;
+declare const RegisterRequestSchema: z.ZodObject<{
+    /** Human-readable name for this agent (e.g. "MacBook Pro") */
+    name: z.ZodString;
+    namespaceId: z.ZodString;
+    capabilities: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    /**
+     * X25519 public key for E2E encryption, base64url encoded.
+     * Generated by the agent; the server stores it for encrypting call payloads.
+     */
+    publicKey: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    namespaceId: string;
+    capabilities: string[];
+    name: string;
+    publicKey?: string | undefined;
+}, {
+    namespaceId: string;
+    name: string;
+    capabilities?: string[] | undefined;
+    publicKey?: string | undefined;
+}>;
+declare const RegisterResponseSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+    hostId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    hostId: string;
+    clientId: string;
+    clientSecret: string;
+}, {
+    hostId: string;
+    clientId: string;
+    clientSecret: string;
+}>;
+declare const TokenRequestSchema: z.ZodObject<{
+    clientId: z.ZodString;
+    clientSecret: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    clientId: string;
+    clientSecret: string;
+}, {
+    clientId: string;
+    clientSecret: string;
+}>;
+declare const TokenResponseSchema: z.ZodObject<{
+    accessToken: z.ZodString;
+    refreshToken: z.ZodString;
+    /** Seconds until accessToken expires */
+    expiresIn: z.ZodNumber;
+    tokenType: z.ZodLiteral<"Bearer">;
+}, "strip", z.ZodTypeAny, {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    tokenType: "Bearer";
+}, {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    tokenType: "Bearer";
+}>;
+declare const RefreshRequestSchema: z.ZodObject<{
+    refreshToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    refreshToken: string;
+}, {
+    refreshToken: string;
+}>;
+/** JWT payload (sub = hostId) */
+declare const JwtPayloadSchema: z.ZodObject<{
+    sub: z.ZodString;
+    namespaceId: z.ZodString;
+    tier: z.ZodEnum<["free", "pro", "enterprise"]>;
+    type: z.ZodEnum<["user", "cli", "machine"]>;
+    iat: z.ZodNumber;
+    exp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "user" | "cli" | "machine";
+    namespaceId: string;
+    tier: "free" | "pro" | "enterprise";
+    sub: string;
+    iat: number;
+    exp: number;
+}, {
+    type: "user" | "cli" | "machine";
+    namespaceId: string;
+    tier: "free" | "pro" | "enterprise";
+    sub: string;
+    iat: number;
+    exp: number;
+}>;
+type RegisterRequest = z.infer<typeof RegisterRequestSchema>;
+type RegisterResponse = z.infer<typeof RegisterResponseSchema>;
+type TokenRequest = z.infer<typeof TokenRequestSchema>;
+type TokenResponse = z.infer<typeof TokenResponseSchema>;
+type RefreshRequest = z.infer<typeof RefreshRequestSchema>;
+type JwtPayload = z.infer<typeof JwtPayloadSchema>;
+
+declare const TraceContextSchema: z.ZodObject<{
+    traceId: z.ZodString;
+    spanId: z.ZodString;
+    parentId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    traceId: string;
+    spanId: string;
+    parentId?: string | undefined;
+}, {
+    traceId: string;
+    spanId: string;
+    parentId?: string | undefined;
+}>;
+declare const WorkspaceInfoSchema: z.ZodObject<{
+    workspaceId: z.ZodString;
+    repoFingerprint: z.ZodOptional<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    workspaceId: string;
+    repoFingerprint?: string | undefined;
+    branch?: string | undefined;
+}, {
+    workspaceId: string;
+    repoFingerprint?: string | undefined;
+    branch?: string | undefined;
+}>;
+declare const PluginInfoSchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    version: string;
+}, {
+    id: string;
+    version: string;
+}>;
+declare const HelloMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"hello">;
+    protocolVersion: z.ZodString;
+    agentVersion: z.ZodString;
+    hostId: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    hostType: z.ZodOptional<z.ZodEnum<["local", "cloud"]>>;
+    workspaces: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        workspaceId: z.ZodString;
+        repoFingerprint: z.ZodOptional<z.ZodString>;
+        branch: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        workspaceId: string;
+        repoFingerprint?: string | undefined;
+        branch?: string | undefined;
+    }, {
+        workspaceId: string;
+        repoFingerprint?: string | undefined;
+        branch?: string | undefined;
+    }>, "many">>;
+    plugins: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        version: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        version: string;
+    }, {
+        id: string;
+        version: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    type: "hello";
+    protocolVersion: string;
+    agentVersion: string;
+    hostId?: string | undefined;
+    capabilities?: string[] | undefined;
+    hostType?: "local" | "cloud" | undefined;
+    workspaces?: {
+        workspaceId: string;
+        repoFingerprint?: string | undefined;
+        branch?: string | undefined;
+    }[] | undefined;
+    plugins?: {
+        id: string;
+        version: string;
+    }[] | undefined;
+}, {
+    type: "hello";
+    protocolVersion: string;
+    agentVersion: string;
+    hostId?: string | undefined;
+    capabilities?: string[] | undefined;
+    hostType?: "local" | "cloud" | undefined;
+    workspaces?: {
+        workspaceId: string;
+        repoFingerprint?: string | undefined;
+        branch?: string | undefined;
+    }[] | undefined;
+    plugins?: {
+        id: string;
+        version: string;
+    }[] | undefined;
+}>;
+declare const ConnectedMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"connected">;
+    protocolVersion: z.ZodString;
+    hostId: z.ZodString;
+    sessionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "connected";
+    hostId: string;
+    protocolVersion: string;
+    sessionId: string;
+}, {
+    type: "connected";
+    hostId: string;
+    protocolVersion: string;
+    sessionId: string;
+}>;
+declare const NegotiateMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"negotiate">;
+    supportedVersions: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    type: "negotiate";
+    supportedVersions: string[];
+}, {
+    type: "negotiate";
+    supportedVersions: string[];
+}>;
+declare const CallMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"call">;
+    requestId: z.ZodString;
+    adapter: z.ZodString;
+    method: z.ZodString;
+    args: z.ZodArray<z.ZodUnknown, "many">;
+    bulk: z.ZodOptional<z.ZodBoolean>;
+    trace: z.ZodObject<{
+        traceId: z.ZodString;
+        spanId: z.ZodString;
+        parentId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        traceId: string;
+        spanId: string;
+        parentId?: string | undefined;
+    }, {
+        traceId: string;
+        spanId: string;
+        parentId?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "call";
+    requestId: string;
+    adapter: string;
+    method: string;
+    args: unknown[];
+    trace: {
+        traceId: string;
+        spanId: string;
+        parentId?: string | undefined;
+    };
+    bulk?: boolean | undefined;
+}, {
+    type: "call";
+    requestId: string;
+    adapter: string;
+    method: string;
+    args: unknown[];
+    trace: {
+        traceId: string;
+        spanId: string;
+        parentId?: string | undefined;
+    };
+    bulk?: boolean | undefined;
+}>;
+declare const BulkRedirectMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"bulk-redirect">;
+    requestId: z.ZodString;
+    uploadUrl: z.ZodString;
+    expiresAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "bulk-redirect";
+    requestId: string;
+    uploadUrl: string;
+    expiresAt: number;
+}, {
+    type: "bulk-redirect";
+    requestId: string;
+    uploadUrl: string;
+    expiresAt: number;
+}>;
+declare const ChunkMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"chunk">;
+    requestId: z.ZodString;
+    data: z.ZodUnknown;
+    index: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "chunk";
+    requestId: string;
+    index: number;
+    data?: unknown;
+}, {
+    type: "chunk";
+    requestId: string;
+    index: number;
+    data?: unknown;
+}>;
+declare const ResultMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"result">;
+    requestId: z.ZodString;
+    done: z.ZodLiteral<true>;
+    trace: z.ZodOptional<z.ZodObject<{
+        traceId: z.ZodString;
+        spanId: z.ZodString;
+        parentId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        traceId: string;
+        spanId: string;
+        parentId?: string | undefined;
+    }, {
+        traceId: string;
+        spanId: string;
+        parentId?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    type: "result";
+    requestId: string;
+    done: true;
+    trace?: {
+        traceId: string;
+        spanId: string;
+        parentId?: string | undefined;
+    } | undefined;
+}, {
+    type: "result";
+    requestId: string;
+    done: true;
+    trace?: {
+        traceId: string;
+        spanId: string;
+        parentId?: string | undefined;
+    } | undefined;
+}>;
+declare const ErrorMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    requestId: z.ZodString;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        retryable: boolean;
+    }, {
+        code: string;
+        message: string;
+        retryable: boolean;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "error";
+    requestId: string;
+    error: {
+        code: string;
+        message: string;
+        retryable: boolean;
+    };
+}, {
+    type: "error";
+    requestId: string;
+    error: {
+        code: string;
+        message: string;
+        retryable: boolean;
+    };
+}>;
+declare const HeartbeatMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"heartbeat">;
+}, "strip", z.ZodTypeAny, {
+    type: "heartbeat";
+}, {
+    type: "heartbeat";
+}>;
+declare const AckMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"ack">;
+}, "strip", z.ZodTypeAny, {
+    type: "ack";
+}, {
+    type: "ack";
+}>;
+declare const ExecutionOutputSchema: z.ZodObject<{
+    type: z.ZodLiteral<"execution:output">;
+    requestId: z.ZodString;
+    executionId: z.ZodString;
+    stream: z.ZodEnum<["stdout", "stderr"]>;
+    data: z.ZodString;
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "execution:output";
+    requestId: string;
+    data: string;
+    executionId: string;
+    stream: "stdout" | "stderr";
+    timestamp: number;
+}, {
+    type: "execution:output";
+    requestId: string;
+    data: string;
+    executionId: string;
+    stream: "stdout" | "stderr";
+    timestamp: number;
+}>;
+declare const ExecutionProgressSchema: z.ZodObject<{
+    type: z.ZodLiteral<"execution:progress">;
+    requestId: z.ZodString;
+    executionId: z.ZodString;
+    step: z.ZodNumber;
+    total: z.ZodNumber;
+    label: z.ZodString;
+    timestamp: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "execution:progress";
+    requestId: string;
+    executionId: string;
+    timestamp: number;
+    step: number;
+    total: number;
+    label: string;
+}, {
+    type: "execution:progress";
+    requestId: string;
+    executionId: string;
+    timestamp: number;
+    step: number;
+    total: number;
+    label: string;
+}>;
+declare const ExecutionArtifactSchema: z.ZodObject<{
+    type: z.ZodLiteral<"execution:artifact">;
+    requestId: z.ZodString;
+    executionId: z.ZodString;
+    name: z.ZodString;
+    mime: z.ZodString;
+    url: z.ZodString;
+    sizeBytes: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    type: "execution:artifact";
+    requestId: string;
+    executionId: string;
+    name: string;
+    mime: string;
+    sizeBytes?: number | undefined;
+}, {
+    url: string;
+    type: "execution:artifact";
+    requestId: string;
+    executionId: string;
+    name: string;
+    mime: string;
+    sizeBytes?: number | undefined;
+}>;
+declare const ExecutionErrorEventSchema: z.ZodObject<{
+    type: z.ZodLiteral<"execution:error">;
+    requestId: z.ZodString;
+    executionId: z.ZodString;
+    code: z.ZodString;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+    attempt: z.ZodOptional<z.ZodNumber>;
+    maxAttempts: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    type: "execution:error";
+    requestId: string;
+    retryable: boolean;
+    executionId: string;
+    attempt?: number | undefined;
+    maxAttempts?: number | undefined;
+}, {
+    code: string;
+    message: string;
+    type: "execution:error";
+    requestId: string;
+    retryable: boolean;
+    executionId: string;
+    attempt?: number | undefined;
+    maxAttempts?: number | undefined;
+}>;
+declare const ExecutionDoneSchema: z.ZodObject<{
+    type: z.ZodLiteral<"execution:done">;
+    requestId: z.ZodString;
+    executionId: z.ZodString;
+    exitCode: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type: "execution:done";
+    requestId: string;
+    executionId: string;
+    exitCode: number;
+    durationMs: number;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    type: "execution:done";
+    requestId: string;
+    executionId: string;
+    exitCode: number;
+    durationMs: number;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+declare const ExecutionRetrySchema: z.ZodObject<{
+    type: z.ZodLiteral<"execution:retry">;
+    requestId: z.ZodString;
+    executionId: z.ZodString;
+    attempt: z.ZodNumber;
+    maxAttempts: z.ZodNumber;
+    delayMs: z.ZodNumber;
+    error: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "execution:retry";
+    requestId: string;
+    error: string;
+    executionId: string;
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+}, {
+    type: "execution:retry";
+    requestId: string;
+    error: string;
+    executionId: string;
+    attempt: number;
+    maxAttempts: number;
+    delayMs: number;
+}>;
+declare const ExecutionCancelledSchema: z.ZodObject<{
+    type: z.ZodLiteral<"execution:cancelled">;
+    requestId: z.ZodString;
+    executionId: z.ZodString;
+    reason: z.ZodEnum<["user", "timeout", "disconnect", "system"]>;
+    durationMs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "execution:cancelled";
+    requestId: string;
+    executionId: string;
+    durationMs: number;
+    reason: "user" | "timeout" | "disconnect" | "system";
+}, {
+    type: "execution:cancelled";
+    requestId: string;
+    executionId: string;
+    durationMs: number;
+    reason: "user" | "timeout" | "disconnect" | "system";
+}>;
+declare const CancelMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"cancel">;
+    requestId: z.ZodString;
+    reason: z.ZodOptional<z.ZodEnum<["user", "timeout", "disconnect"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "cancel";
+    requestId: string;
+    reason?: "user" | "timeout" | "disconnect" | undefined;
+}, {
+    type: "cancel";
+    requestId: string;
+    reason?: "user" | "timeout" | "disconnect" | undefined;
+}>;
+declare const SubscribeMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"subscribe">;
+    executionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "subscribe";
+    executionId: string;
+}, {
+    type: "subscribe";
+    executionId: string;
+}>;
+declare const UnsubscribeMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"unsubscribe">;
+    executionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "unsubscribe";
+    executionId: string;
+}, {
+    type: "unsubscribe";
+    executionId: string;
+}>;
+/** Serialized error for adapter:error messages */
+declare const SerializedErrorSchema: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    retryable: z.ZodBoolean;
+    details: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    code: string;
+    message: string;
+    retryable: boolean;
+    details?: unknown;
+}, {
+    code: string;
+    message: string;
+    retryable: boolean;
+    details?: unknown;
+}>;
+/** Adapter call context — propagated from host to platform */
+declare const AdapterCallContextSchema: z.ZodObject<{
+    namespaceId: z.ZodString;
+    hostId: z.ZodString;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    environmentId: z.ZodOptional<z.ZodString>;
+    executionRequestId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    hostId: string;
+    namespaceId: string;
+    workspaceId?: string | undefined;
+    environmentId?: string | undefined;
+    executionRequestId?: string | undefined;
+}, {
+    hostId: string;
+    namespaceId: string;
+    workspaceId?: string | undefined;
+    environmentId?: string | undefined;
+    executionRequestId?: string | undefined;
+}>;
+/** Allowed adapter names for reverse proxy */
+declare const AdapterNameSchema: z.ZodEnum<["llm", "cache", "vectorStore", "embeddings", "storage", "state"]>;
+declare const AdapterCallMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"adapter:call">;
+    requestId: z.ZodString;
+    adapter: z.ZodEnum<["llm", "cache", "vectorStore", "embeddings", "storage", "state"]>;
+    method: z.ZodString;
+    args: z.ZodArray<z.ZodUnknown, "many">;
+    timeout: z.ZodOptional<z.ZodNumber>;
+    context: z.ZodObject<{
+        namespaceId: z.ZodString;
+        hostId: z.ZodString;
+        workspaceId: z.ZodOptional<z.ZodString>;
+        environmentId: z.ZodOptional<z.ZodString>;
+        executionRequestId: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        hostId: string;
+        namespaceId: string;
+        workspaceId?: string | undefined;
+        environmentId?: string | undefined;
+        executionRequestId?: string | undefined;
+    }, {
+        hostId: string;
+        namespaceId: string;
+        workspaceId?: string | undefined;
+        environmentId?: string | undefined;
+        executionRequestId?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "adapter:call";
+    requestId: string;
+    adapter: "llm" | "cache" | "vectorStore" | "embeddings" | "storage" | "state";
+    method: string;
+    args: unknown[];
+    context: {
+        hostId: string;
+        namespaceId: string;
+        workspaceId?: string | undefined;
+        environmentId?: string | undefined;
+        executionRequestId?: string | undefined;
+    };
+    timeout?: number | undefined;
+}, {
+    type: "adapter:call";
+    requestId: string;
+    adapter: "llm" | "cache" | "vectorStore" | "embeddings" | "storage" | "state";
+    method: string;
+    args: unknown[];
+    context: {
+        hostId: string;
+        namespaceId: string;
+        workspaceId?: string | undefined;
+        environmentId?: string | undefined;
+        executionRequestId?: string | undefined;
+    };
+    timeout?: number | undefined;
+}>;
+declare const AdapterResponseMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"adapter:response">;
+    requestId: z.ZodString;
+    result: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type: "adapter:response";
+    requestId: string;
+    result?: unknown;
+}, {
+    type: "adapter:response";
+    requestId: string;
+    result?: unknown;
+}>;
+declare const AdapterErrorMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"adapter:error">;
+    requestId: z.ZodString;
+    error: z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        retryable: z.ZodBoolean;
+        details: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        code: string;
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+    }, {
+        code: string;
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    type: "adapter:error";
+    requestId: string;
+    error: {
+        code: string;
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+    };
+}, {
+    type: "adapter:error";
+    requestId: string;
+    error: {
+        code: string;
+        message: string;
+        retryable: boolean;
+        details?: unknown;
+    };
+}>;
+declare const AdapterChunkMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"adapter:chunk">;
+    requestId: z.ZodString;
+    data: z.ZodUnknown;
+    index: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    type: "adapter:chunk";
+    requestId: string;
+    index: number;
+    data?: unknown;
+}, {
+    type: "adapter:chunk";
+    requestId: string;
+    index: number;
+    data?: unknown;
+}>;
+declare const AdapterCancelMessageSchema: z.ZodObject<{
+    type: z.ZodLiteral<"adapter:cancel">;
+    requestId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "adapter:cancel";
+    requestId: string;
+}, {
+    type: "adapter:cancel";
+    requestId: string;
+}>;
+declare const ExecuteRequestSchema: z.ZodObject<{
+    pluginId: z.ZodString;
+    handlerRef: z.ZodString;
+    exportName: z.ZodOptional<z.ZodString>;
+    input: z.ZodUnknown;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    pluginId: string;
+    handlerRef: string;
+    exportName?: string | undefined;
+    input?: unknown;
+    timeoutMs?: number | undefined;
+}, {
+    pluginId: string;
+    handlerRef: string;
+    exportName?: string | undefined;
+    input?: unknown;
+    timeoutMs?: number | undefined;
+}>;
+declare const SUPPORTED_PROTOCOL_VERSIONS: readonly ["1.0"];
+type TraceContext = z.infer<typeof TraceContextSchema>;
+type HelloMessage = z.infer<typeof HelloMessageSchema>;
+type ConnectedMessage = z.infer<typeof ConnectedMessageSchema>;
+type NegotiateMessage = z.infer<typeof NegotiateMessageSchema>;
+type CallMessage = z.infer<typeof CallMessageSchema>;
+type BulkRedirectMessage = z.infer<typeof BulkRedirectMessageSchema>;
+type ChunkMessage = z.infer<typeof ChunkMessageSchema>;
+type ResultMessage = z.infer<typeof ResultMessageSchema>;
+type ErrorMessage = z.infer<typeof ErrorMessageSchema>;
+type HeartbeatMessage = z.infer<typeof HeartbeatMessageSchema>;
+type AckMessage = z.infer<typeof AckMessageSchema>;
+type ExecutionOutputMessage = z.infer<typeof ExecutionOutputSchema>;
+type ExecutionProgressMessage = z.infer<typeof ExecutionProgressSchema>;
+type ExecutionArtifactMessage = z.infer<typeof ExecutionArtifactSchema>;
+type ExecutionErrorEventMessage = z.infer<typeof ExecutionErrorEventSchema>;
+type ExecutionDoneMessage = z.infer<typeof ExecutionDoneSchema>;
+type ExecutionRetryMessage = z.infer<typeof ExecutionRetrySchema>;
+type ExecutionCancelledMessage = z.infer<typeof ExecutionCancelledSchema>;
+type CancelMessage = z.infer<typeof CancelMessageSchema>;
+type SubscribeMessage = z.infer<typeof SubscribeMessageSchema>;
+type UnsubscribeMessage = z.infer<typeof UnsubscribeMessageSchema>;
+type ExecuteRequest = z.infer<typeof ExecuteRequestSchema>;
+type WorkspaceInfo = z.infer<typeof WorkspaceInfoSchema>;
+type PluginInfo = z.infer<typeof PluginInfoSchema>;
+type SerializedError = z.infer<typeof SerializedErrorSchema>;
+type AdapterCallContext = z.infer<typeof AdapterCallContextSchema>;
+type AdapterName = z.infer<typeof AdapterNameSchema>;
+type AdapterCallMessage = z.infer<typeof AdapterCallMessageSchema>;
+type AdapterResponseMessage = z.infer<typeof AdapterResponseMessageSchema>;
+type AdapterErrorMessage = z.infer<typeof AdapterErrorMessageSchema>;
+type AdapterChunkMessage = z.infer<typeof AdapterChunkMessageSchema>;
+type AdapterCancelMessage = z.infer<typeof AdapterCancelMessageSchema>;
+type ExecutionEventMessage = ExecutionOutputMessage | ExecutionProgressMessage | ExecutionArtifactMessage | ExecutionErrorEventMessage | ExecutionDoneMessage | ExecutionRetryMessage | ExecutionCancelledMessage;
+type InboundMessage = HelloMessage | HeartbeatMessage | ChunkMessage | ResultMessage | ErrorMessage | CancelMessage | SubscribeMessage | UnsubscribeMessage | AdapterCallMessage | AdapterCancelMessage;
+type OutboundMessage = ConnectedMessage | NegotiateMessage | CallMessage | BulkRedirectMessage | AckMessage | ExecutionOutputMessage | ExecutionProgressMessage | ExecutionArtifactMessage | ExecutionErrorEventMessage | ExecutionDoneMessage | AdapterResponseMessage | AdapterErrorMessage | AdapterChunkMessage;
+
+/**
+ * @module gateway-contracts/client-protocol
+ *
+ * WS protocol for observer clients (CLI, Studio, IDE).
+ * Endpoint: /clients/connect
+ *
+ * Separate from host-protocol (protocol.ts) — clients observe executions,
+ * they don't serve adapter calls.
+ *
+ * Client → Gateway inbound messages:
+ *   - client:hello     — handshake
+ *   - client:subscribe — subscribe to execution events
+ *   - client:unsubscribe
+ *   - client:cancel    — cancel an execution (convenience, same as POST /execute/:id/cancel)
+ *
+ * Gateway → Client outbound messages:
+ *   - client:connected   — handshake ack
+ *   - execution:output   — (reused from protocol.ts ExecutionEventMessage)
+ *   - execution:progress
+ *   - execution:artifact
+ *   - execution:error
+ *   - execution:done
+ *   - client:error       — protocol-level error (bad subscribe, not found, etc.)
+ */
+
+declare const ClientHelloSchema: z.ZodObject<{
+    type: z.ZodLiteral<"client:hello">;
+    clientVersion: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "client:hello";
+    clientVersion: string;
+}, {
+    type: "client:hello";
+    clientVersion: string;
+}>;
+declare const ClientSubscribeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"client:subscribe">;
+    executionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "client:subscribe";
+    executionId: string;
+}, {
+    type: "client:subscribe";
+    executionId: string;
+}>;
+declare const ClientUnsubscribeSchema: z.ZodObject<{
+    type: z.ZodLiteral<"client:unsubscribe">;
+    executionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "client:unsubscribe";
+    executionId: string;
+}, {
+    type: "client:unsubscribe";
+    executionId: string;
+}>;
+declare const ClientCancelSchema: z.ZodObject<{
+    type: z.ZodLiteral<"client:cancel">;
+    executionId: z.ZodString;
+    reason: z.ZodOptional<z.ZodEnum<["user", "timeout"]>>;
+}, "strip", z.ZodTypeAny, {
+    type: "client:cancel";
+    executionId: string;
+    reason?: "user" | "timeout" | undefined;
+}, {
+    type: "client:cancel";
+    executionId: string;
+    reason?: "user" | "timeout" | undefined;
+}>;
+declare const ClientConnectedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"client:connected">;
+    protocolVersion: z.ZodString;
+    connectionId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    type: "client:connected";
+    protocolVersion: string;
+    connectionId: string;
+}, {
+    type: "client:connected";
+    protocolVersion: string;
+    connectionId: string;
+}>;
+declare const ClientErrorSchema: z.ZodObject<{
+    type: z.ZodLiteral<"client:error">;
+    code: z.ZodEnum<["EXECUTION_NOT_FOUND", "FORBIDDEN", "INVALID_MESSAGE", "CANCEL_FAILED"]>;
+    message: z.ZodString;
+    executionId: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    code: "EXECUTION_NOT_FOUND" | "FORBIDDEN" | "INVALID_MESSAGE" | "CANCEL_FAILED";
+    message: string;
+    type: "client:error";
+    executionId?: string | undefined;
+}, {
+    code: "EXECUTION_NOT_FOUND" | "FORBIDDEN" | "INVALID_MESSAGE" | "CANCEL_FAILED";
+    message: string;
+    type: "client:error";
+    executionId?: string | undefined;
+}>;
+type ClientHello = z.infer<typeof ClientHelloSchema>;
+type ClientSubscribe = z.infer<typeof ClientSubscribeSchema>;
+type ClientUnsubscribe = z.infer<typeof ClientUnsubscribeSchema>;
+type ClientCancel = z.infer<typeof ClientCancelSchema>;
+type ClientConnected = z.infer<typeof ClientConnectedSchema>;
+type ClientError = z.infer<typeof ClientErrorSchema>;
+type ClientInboundMessage = ClientHello | ClientSubscribe | ClientUnsubscribe | ClientCancel;
+type ClientOutboundMessage = ClientConnected | ClientError | ExecutionEventMessage;
+declare const CLIENT_PROTOCOL_VERSION = "1.0";
+
+/**
+ * @module @kb-labs/gateway-contracts/llm-gateway
+ * OpenAI-compatible AI Gateway schemas and types.
+ *
+ * Clients interact using OpenAI ChatCompletion format, but `model` field
+ * is a tier abstraction (small/medium/large/fast), NOT a literal model name.
+ * The platform resolves the tier to a concrete provider + model via LLMRouter config.
+ */
+
+/** Tier-based model selector. Clients never specify a concrete model. */
+declare const LLMTierSchema: z.ZodEnum<["small", "medium", "large"]>;
+declare const ChatMessageSchema: z.ZodObject<{
+    role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+    content: z.ZodString;
+    tool_call_id: z.ZodOptional<z.ZodString>;
+    tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodLiteral<"function">;
+        function: z.ZodObject<{
+            name: z.ZodString;
+            arguments: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            arguments: string;
+        }, {
+            name: string;
+            arguments: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        function: {
+            name: string;
+            arguments: string;
+        };
+        type: "function";
+        id: string;
+    }, {
+        function: {
+            name: string;
+            arguments: string;
+        };
+        type: "function";
+        id: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    role: "user" | "system" | "assistant" | "tool";
+    content: string;
+    tool_call_id?: string | undefined;
+    tool_calls?: {
+        function: {
+            name: string;
+            arguments: string;
+        };
+        type: "function";
+        id: string;
+    }[] | undefined;
+}, {
+    role: "user" | "system" | "assistant" | "tool";
+    content: string;
+    tool_call_id?: string | undefined;
+    tool_calls?: {
+        function: {
+            name: string;
+            arguments: string;
+        };
+        type: "function";
+        id: string;
+    }[] | undefined;
+}>;
+declare const ChatToolSchema: z.ZodObject<{
+    type: z.ZodLiteral<"function">;
+    function: z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description?: string | undefined;
+        parameters?: Record<string, unknown> | undefined;
+    }, {
+        name: string;
+        description?: string | undefined;
+        parameters?: Record<string, unknown> | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    function: {
+        name: string;
+        description?: string | undefined;
+        parameters?: Record<string, unknown> | undefined;
+    };
+    type: "function";
+}, {
+    function: {
+        name: string;
+        description?: string | undefined;
+        parameters?: Record<string, unknown> | undefined;
+    };
+    type: "function";
+}>;
+declare const ChatCompletionRequestSchema: z.ZodObject<{
+    /** Tier-based model selector: "small" | "medium" | "large" | "fast" */
+    model: z.ZodEnum<["small", "medium", "large"]>;
+    messages: z.ZodArray<z.ZodObject<{
+        role: z.ZodEnum<["system", "user", "assistant", "tool"]>;
+        content: z.ZodString;
+        tool_call_id: z.ZodOptional<z.ZodString>;
+        tool_calls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodLiteral<"function">;
+            function: z.ZodObject<{
+                name: z.ZodString;
+                arguments: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                name: string;
+                arguments: string;
+            }, {
+                name: string;
+                arguments: string;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }, {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        role: "user" | "system" | "assistant" | "tool";
+        content: string;
+        tool_call_id?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+    }, {
+        role: "user" | "system" | "assistant" | "tool";
+        content: string;
+        tool_call_id?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+    }>, "many">;
+    temperature: z.ZodOptional<z.ZodNumber>;
+    max_tokens: z.ZodOptional<z.ZodNumber>;
+    stop: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>;
+    stream: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodObject<{
+            name: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            description?: string | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        }, {
+            name: string;
+            description?: string | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        function: {
+            name: string;
+            description?: string | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        };
+        type: "function";
+    }, {
+        function: {
+            name: string;
+            description?: string | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        };
+        type: "function";
+    }>, "many">>;
+    tool_choice: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["auto", "required", "none"]>, z.ZodObject<{
+        type: z.ZodLiteral<"function">;
+        function: z.ZodObject<{
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+        }, {
+            name: string;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        function: {
+            name: string;
+        };
+        type: "function";
+    }, {
+        function: {
+            name: string;
+        };
+        type: "function";
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    stream: boolean;
+    model: "small" | "medium" | "large";
+    messages: {
+        role: "user" | "system" | "assistant" | "tool";
+        content: string;
+        tool_call_id?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+    }[];
+    temperature?: number | undefined;
+    max_tokens?: number | undefined;
+    stop?: string | string[] | undefined;
+    tools?: {
+        function: {
+            name: string;
+            description?: string | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        };
+        type: "function";
+    }[] | undefined;
+    tool_choice?: "required" | "auto" | "none" | {
+        function: {
+            name: string;
+        };
+        type: "function";
+    } | undefined;
+}, {
+    model: "small" | "medium" | "large";
+    messages: {
+        role: "user" | "system" | "assistant" | "tool";
+        content: string;
+        tool_call_id?: string | undefined;
+        tool_calls?: {
+            function: {
+                name: string;
+                arguments: string;
+            };
+            type: "function";
+            id: string;
+        }[] | undefined;
+    }[];
+    stream?: boolean | undefined;
+    temperature?: number | undefined;
+    max_tokens?: number | undefined;
+    stop?: string | string[] | undefined;
+    tools?: {
+        function: {
+            name: string;
+            description?: string | undefined;
+            parameters?: Record<string, unknown> | undefined;
+        };
+        type: "function";
+    }[] | undefined;
+    tool_choice?: "required" | "auto" | "none" | {
+        function: {
+            name: string;
+        };
+        type: "function";
+    } | undefined;
+}>;
+type ChatCompletionRequest = z.infer<typeof ChatCompletionRequestSchema>;
+interface ChatCompletionChoice {
+    index: number;
+    message: {
+        role: 'assistant';
+        content: string | null;
+        tool_calls?: Array<{
+            id: string;
+            type: 'function';
+            function: {
+                name: string;
+                arguments: string;
+            };
+        }>;
+    };
+    finish_reason: 'stop' | 'tool_calls' | 'length' | null;
+}
+interface ChatCompletionUsage {
+    prompt_tokens: number;
+    completion_tokens: number;
+    total_tokens: number;
+}
+interface ChatCompletionResponse {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    /** Returns the tier used, not the concrete model (abstraction preserved) */
+    model: string;
+    choices: ChatCompletionChoice[];
+    usage: ChatCompletionUsage;
+}
+interface ChatCompletionChunkDelta {
+    role?: 'assistant';
+    content?: string | null;
+    tool_calls?: Array<{
+        index: number;
+        id?: string;
+        type?: 'function';
+        function?: {
+            name?: string;
+            arguments?: string;
+        };
+    }>;
+}
+interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: ChatCompletionChunkDelta;
+        finish_reason: 'stop' | 'tool_calls' | 'length' | null;
+    }>;
+}
+
+/**
+ * @module @kb-labs/gateway-contracts/telemetry
+ * Telemetry ingestion schemas for the AI Gateway.
+ *
+ * External products send events through `POST /telemetry/v1/ingest`.
+ * Events are written to platform analytics (SQLite/DuckDB/File) via IAnalytics.track().
+ *
+ * Schema is intentionally minimal — `payload` is free-form.
+ * Platform provides recommended presets but does not enforce them.
+ */
+
+declare const TelemetryEventSchema: z.ZodObject<{
+    /** Source product/service name (e.g., "my-api", "billing-service") */
+    source: z.ZodString;
+    /** Event type/name using dot notation (e.g., "user.signup", "api.request") */
+    type: z.ZodString;
+    /** ISO 8601 timestamp. Defaults to server ingest time if omitted. */
+    timestamp: z.ZodOptional<z.ZodString>;
+    /** Free-form event data. No schema enforced — products decide what to send. */
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    /** Flat key-value tags for filtering/aggregation (e.g., { env: "prod", region: "eu" }) */
+    tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    source: string;
+    timestamp?: string | undefined;
+    payload?: Record<string, unknown> | undefined;
+    tags?: Record<string, string> | undefined;
+}, {
+    type: string;
+    source: string;
+    timestamp?: string | undefined;
+    payload?: Record<string, unknown> | undefined;
+    tags?: Record<string, string> | undefined;
+}>;
+type TelemetryEvent = z.infer<typeof TelemetryEventSchema>;
+declare const TelemetryIngestRequestSchema: z.ZodObject<{
+    /** Array of events to ingest (1–500 per batch) */
+    events: z.ZodArray<z.ZodObject<{
+        /** Source product/service name (e.g., "my-api", "billing-service") */
+        source: z.ZodString;
+        /** Event type/name using dot notation (e.g., "user.signup", "api.request") */
+        type: z.ZodString;
+        /** ISO 8601 timestamp. Defaults to server ingest time if omitted. */
+        timestamp: z.ZodOptional<z.ZodString>;
+        /** Free-form event data. No schema enforced — products decide what to send. */
+        payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        /** Flat key-value tags for filtering/aggregation (e.g., { env: "prod", region: "eu" }) */
+        tags: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        type: string;
+        source: string;
+        timestamp?: string | undefined;
+        payload?: Record<string, unknown> | undefined;
+        tags?: Record<string, string> | undefined;
+    }, {
+        type: string;
+        source: string;
+        timestamp?: string | undefined;
+        payload?: Record<string, unknown> | undefined;
+        tags?: Record<string, string> | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    events: {
+        type: string;
+        source: string;
+        timestamp?: string | undefined;
+        payload?: Record<string, unknown> | undefined;
+        tags?: Record<string, string> | undefined;
+    }[];
+}, {
+    events: {
+        type: string;
+        source: string;
+        timestamp?: string | undefined;
+        payload?: Record<string, unknown> | undefined;
+        tags?: Record<string, string> | undefined;
+    }[];
+}>;
+type TelemetryIngestRequest = z.infer<typeof TelemetryIngestRequestSchema>;
+interface TelemetryIngestResponse {
+    /** Number of events accepted */
+    accepted: number;
+    /** Number of events rejected (validation errors) */
+    rejected: number;
+    /** Errors for rejected events, if any */
+    errors?: Array<{
+        index: number;
+        message: string;
+    }>;
+}
+
+/**
+ * @module @kb-labs/gateway-contracts/platform-api
+ * Unified Platform API — single dispatch endpoint for any adapter.
+ *
+ * Route: POST /platform/v1/{adapter}/{method}
+ * Adapter and method come from URL params; args come from the request body.
+ */
+
+declare const PlatformCallRequestSchema: z.ZodObject<{
+    /** Arguments to pass to the adapter method. Order matters. */
+    args: z.ZodDefault<z.ZodArray<z.ZodUnknown, "many">>;
+}, "strip", z.ZodTypeAny, {
+    args: unknown[];
+}, {
+    args?: unknown[] | undefined;
+}>;
+type PlatformCallRequest = z.infer<typeof PlatformCallRequestSchema>;
+interface PlatformCallResponse {
+    ok: boolean;
+    result?: unknown;
+    error?: {
+        message: string;
+        code?: string;
+    };
+    /** Wall-clock duration of the adapter call in milliseconds. */
+    durationMs: number;
+}
+
+export { type AckMessage, AckMessageSchema, type AdapterCallContext, AdapterCallContextSchema, type AdapterCallMessage, AdapterCallMessageSchema, type AdapterCancelMessage, AdapterCancelMessageSchema, type AdapterChunkMessage, AdapterChunkMessageSchema, type AdapterErrorMessage, AdapterErrorMessageSchema, type AdapterName, AdapterNameSchema, type AdapterResponseMessage, AdapterResponseMessageSchema, type AuthContext, AuthContextSchema, type BulkRedirectMessage, BulkRedirectMessageSchema, CLIENT_PROTOCOL_VERSION, type CallMessage, CallMessageSchema, type CancelMessage, CancelMessageSchema, type ChatCompletionChoice, type ChatCompletionChunk, type ChatCompletionChunkDelta, type ChatCompletionRequest, ChatCompletionRequestSchema, type ChatCompletionResponse, type ChatCompletionUsage, ChatMessageSchema, ChatToolSchema, type ChunkMessage, ChunkMessageSchema, type ClientCancel, ClientCancelSchema, type ClientConnected, ClientConnectedSchema, type ClientError, ClientErrorSchema, type ClientHello, ClientHelloSchema, type ClientInboundMessage, type ClientOutboundMessage, type ClientSubscribe, ClientSubscribeSchema, type ClientUnsubscribe, ClientUnsubscribeSchema, type ConnectedMessage, ConnectedMessageSchema, type ErrorMessage, ErrorMessageSchema, type ExecuteRequest, ExecuteRequestSchema, type ExecutionArtifactMessage, ExecutionArtifactSchema, type ExecutionCancelledMessage, ExecutionCancelledSchema, type ExecutionDoneMessage, ExecutionDoneSchema, type ExecutionErrorEventMessage, ExecutionErrorEventSchema, type ExecutionEventMessage, type ExecutionOutputMessage, ExecutionOutputSchema, type ExecutionProgressMessage, ExecutionProgressSchema, type ExecutionRetryMessage, ExecutionRetrySchema, type GatewayConfig, GatewayConfigSchema, type HeartbeatMessage, HeartbeatMessageSchema, type HelloMessage, HelloMessageSchema, type HostCapability, HostCapabilitySchema, type HostDescriptor, HostDescriptorSchema, type HostRegisterResponse, HostRegisterResponseSchema, type HostRegistration, HostRegistrationSchema, type HostStatus, HostStatusSchema, type HostType, HostTypeSchema, type IHostStore, type InboundMessage, type JwtPayload, JwtPayloadSchema, LLMTierSchema, type NegotiateMessage, NegotiateMessageSchema, type OutboundMessage, type PlatformCallRequest, PlatformCallRequestSchema, type PlatformCallResponse, type PluginInfo, PluginInfoSchema, type RefreshRequest, RefreshRequestSchema, type RegisterRequest, RegisterRequestSchema, type RegisterResponse, RegisterResponseSchema, type ResultMessage, ResultMessageSchema, SUPPORTED_PROTOCOL_VERSIONS, type SerializedError, SerializedErrorSchema, StaticTokenEntrySchema, type SubscribeMessage, SubscribeMessageSchema, type TelemetryEvent, TelemetryEventSchema, type TelemetryIngestRequest, TelemetryIngestRequestSchema, type TelemetryIngestResponse, type TokenRequest, TokenRequestSchema, type TokenResponse, TokenResponseSchema, type TokenType, TokenTypeSchema, type TraceContext, TraceContextSchema, type UnsubscribeMessage, UnsubscribeMessageSchema, type UpstreamConfig, UpstreamConfigSchema, type WorkspaceInfo, WorkspaceInfoSchema };