@m6d/cortex-server 1.7.0 → 2.0.0

package/contracts/wire.ts

@@ -0,0 +1,143 @@
+/**
+ * The wire contract — every shape that crosses the HTTP/WebSocket boundary
+ * between `@m6d/cortex-server` and the client SDKs (`@m6d/cortex-angular`,
+ * `@m6d/cortex-react`).
+ *
+ * Nothing here has a runtime dependency, and nothing here may grow one: this
+ * file is compiled into an Angular library, a React library and a Bun server
+ * alike.
+ */
+
+export const ATTACHMENT_MIME_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/webp",
+    "application/pdf",
+] as const;
+
+export const ATTACHMENT_MAX_BYTES = 10 * 1024 * 1024;
+
+export const MAX_ATTACHMENTS_PER_MESSAGE = 5;
+
+export const ATTACHMENT_STATUSES = ["pending", "described", "failed", "skipped"] as const;
+
+export function checkAttachmentPolicy(contentType: string, sizeBytes: number) {
+    if (!ATTACHMENT_MIME_TYPES.some((type) => type === contentType)) return "type";
+    if (sizeBytes > ATTACHMENT_MAX_BYTES) return "size";
+    return "ok";
+}
+
+export type AttachmentStatus = (typeof ATTACHMENT_STATUSES)[number];
+
+export type AttachmentSummary = {
+    id: string;
+    filename: string;
+    contentType: string;
+    sizeBytes: number;
+    status: AttachmentStatus;
+    description?: string;
+};
+
+export type ThreadSummary = {
+    id: string;
+    title?: string;
+    createdAt: string;
+    updatedAt: string;
+    isRunning: boolean;
+};
+
+/**
+ * Response of `POST /chat/:chatId/abort`. `aborted: false` means there was no
+ * live run to abort — the turn had already committed — so the caller must not
+ * present the turn as aborted and should read the settled state back instead.
+ */
+export type AbortRunResult = {
+    aborted: boolean;
+};
+
+export type TokenUsage = {
+    input: {
+        noCache: number;
+        cacheRead: number;
+        cacheWrite: number;
+        total: number;
+    };
+    output: {
+        reasoning: number;
+        text: number;
+        total: number;
+    };
+    total: number;
+};
+
+export type MessageMetadata = {
+    modelId?: string;
+    providerMetadata?: unknown;
+    isAborted?: boolean;
+    tokenUsage?: TokenUsage;
+    attachments?: AttachmentSummary[];
+};
+
+/**
+ * A stored message as it is persisted and served. TanStack AI's `UIMessage`
+ * has no metadata field, so cortex owns the envelope: the SDK's parts plus the
+ * server-derived metadata the UI renders on settled messages.
+ *
+ * `TPart` stays generic so this file keeps its zero dependencies — both
+ * sides substitute the SDK's `MessagePart`.
+ */
+export type CortexMessage<TPart = unknown> = {
+    id: string;
+    role: "system" | "user" | "assistant";
+    parts: TPart[];
+    metadata?: MessageMetadata;
+};
+
+export type ThreadCreatedEvent = {
+    type: "thread:created";
+    payload: { thread: ThreadSummary };
+};
+
+export type ThreadDeletedEvent = {
+    type: "thread:deleted";
+    payload: { threadId: string };
+};
+
+export type ThreadTitleUpdatedEvent = {
+    type: "thread:title-updated";
+    payload: { thread: ThreadSummary };
+};
+
+export type ThreadRunStartedEvent = {
+    type: "thread:run-started";
+    payload: { thread: ThreadSummary };
+};
+
+export type ThreadRunFinishedEvent = {
+    type: "thread:run-finished";
+    payload: { thread: ThreadSummary };
+};
+
+export type ThreadMessagesUpdatedEvent = {
+    type: "thread:messages-updated";
+    payload: { threadId: string; thread: ThreadSummary };
+};
+
+export type ToolProgressEvent = {
+    type: "thread:tool-progress";
+    payload: {
+        threadId: string;
+        toolCallId: string;
+        toolName: string;
+        status: "started" | "finished";
+    };
+};
+
+export type WsEvent =
+    | ThreadCreatedEvent
+    | ThreadDeletedEvent
+    | ThreadTitleUpdatedEvent
+    | ThreadRunStartedEvent
+    | ThreadRunFinishedEvent
+    | ThreadMessagesUpdatedEvent
+    | ToolProgressEvent;

package/dist/contracts/graph/embed.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Embeddings, which both halves of the graph need: `@m6d/cortex-cli` embeds every
+ * concept description as it seeds, `@m6d/cortex-server` embeds every prompt as it
+ * resolves. Two embedders would mean two vector spaces, so there is one.
+ *
+ * TanStack AI removed embeddings, and the graph only ever needed the plain
+ * OpenAI-compatible `/embeddings` call cortex is already configured for — so this
+ * is a bare `fetch`, and this package keeps its zero dependencies.
+ *
+ * Everything under `./graph` is written to the oldest target any consumer builds
+ * against — an Angular library compiles these sources directly — and imports
+ * siblings by their `.js` specifier so one emit serves both `dist` and source.
+ */
+/** Everything cortex needs to reach one OpenAI-compatible embeddings endpoint. */
+export type EmbeddingProviderConfig = {
+    baseURL: string;
+    apiKey: string;
+    modelName: string;
+};
+/** Turns a batch of strings into their vectors, in the order given. */
+export type EmbedFn = (values: string[]) => Promise<number[][]>;
+export declare function createEmbedder(config: EmbeddingProviderConfig): (values: string[]) => Promise<number[][]>;

package/dist/{src → contracts}/graph/helpers.d.ts

@@ -1,34 +1,36 @@
 /**
- * Helper functions for building knowledge graph seed data.
+ * Helper functions for building knowledge graph seed data. Projects author
+ * domains with these; `@m6d/cortex-server` re-exports them so authoring needs
+ * exactly one import path.
  */
-import type { ConceptDef, DomainDef, EndpointDef, EndpointInput, RuleDef, ServiceDef } from "./types.ts";
+import type { ConceptDef, DomainDef, EndpointDef, EndpointInput, RuleDef, ServiceDef } from "./types";
 export declare function defineConcept(def: Omit<ConceptDef, "__brand">): {
-    name: string;
     description: string;
+    name: string;
     aliases?: string[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
     parentConcept?: ConceptDef | undefined;
     governedBy?: RuleDef[] | undefined;
-    metadata?: Record<string, unknown> | undefined;
     __brand: "concept";
 };
 export declare function defineRule(def: Omit<RuleDef, "__brand">): {
-    name: string;
     description: string;
+    name: string;
     metadata?: Record<string, unknown> | undefined;
     __brand: "rule";
 };
 export declare function defineService(def: Omit<ServiceDef, "__brand">): {
-    name: string;
     description: string;
-    governedBy?: RuleDef[] | undefined;
+    name: string;
     metadata?: Record<string, unknown> | undefined;
     builtInId: string;
+    governedBy?: RuleDef[] | undefined;
     belongsTo: ConceptDef;
     __brand: "service";
 };
 export declare function defineDomain(def: Omit<DomainDef, "__brand">): {
-    name: string;
     description: string;
+    name: string;
     metadata?: Record<string, unknown> | undefined;
     concepts?: ConceptDef[] | undefined;
     endpoints?: EndpointDef[] | undefined;
@@ -43,12 +45,12 @@ export declare function defineEndpoint(input: EndpointInput): {
     path: string;
     method: "GET" | "POST" | "PUT" | "DELETE";
     propertiesDescriptions: Record<string, string>;
-    params: import("./types.ts").EndpointProperty[];
-    body: import("./types.ts").EndpointProperty[];
-    response: import("./types.ts").EndpointProperty[];
+    params: import("./types").EndpointProperty[];
+    body: import("./types").EndpointProperty[];
+    response: import("./types").EndpointProperty[];
     successStatus: number;
     errorStatuses: number[];
-    responseKind: import("./types.ts").ResponseKind;
+    responseKind: import("./types").ResponseKind;
     queries: ConceptDef[] | undefined;
     mutates: ConceptDef[] | undefined;
     returns: {

package/dist/{src → contracts}/graph/neo4j.d.ts

@@ -1,10 +1,10 @@
 /**
- * Configurable Neo4j HTTP client.
+ * Configurable Neo4j HTTP client, shared by the graph's writer and its reader.
  *
- * Replaces the hardcoded process.env-based client from packages/sample-backend.
- * All configuration is passed explicitly — no environment variables are read.
+ * All configuration is passed explicitly — no environment variables are read —
+ * and the transport is `fetch`, so this package stays dependency-free.
  */
-import type { EmbeddingModel } from "ai";
+import type { EmbedFn } from "./embed";
 export type Neo4jConfig = {
     url: string;
     user: string;
@@ -13,6 +13,6 @@ export type Neo4jConfig = {
 export type Neo4jClient = {
     query(cypher: string, parameters?: Record<string, unknown>): Promise<string>;
 };
-export declare function createNeo4jClient(config: Neo4jConfig, embeddingModel?: EmbeddingModel): {
+export declare function createNeo4jClient(config: Neo4jConfig, embed?: EmbedFn): {
     query: (cypher: string, parameters?: Record<string, unknown>) => Promise<string>;
 };

package/dist/contracts/graph/schema.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The contract between the graph's writer and its reader.
+ *
+ * Seeding lives in `@m6d/cortex-cli` and resolution lives in `@m6d/cortex-server`,
+ * two packages a project installs and upgrades separately. The labels, relationship
+ * types, property names and index name they agree on are this module, here, so
+ * neither side owns the vocabulary the other has to match.
+ *
+ * A mismatch between the two is invisible at runtime: the resolver's Cypher
+ * matches nothing and retrieval comes back empty rather than failing. That is what
+ * `GRAPH_SCHEMA_VERSION` is for — bump it on any change to the shape below. The
+ * CLI stamps the version it wrote onto the graph and the server checks that stamp
+ * on its first resolve, so skew surfaces as an error instead of as silence.
+ */
+export declare const GRAPH_SCHEMA_VERSION = 1;
+export declare const GRAPH_SCHEMA: {
+    readonly label: {
+        readonly domain: "Domain";
+        readonly concept: "Concept";
+        readonly endpoint: "Endpoint";
+        readonly service: "Service";
+        readonly rule: "Rule";
+        /** Stamped with the version above, so a stale graph is detectable later. */
+        readonly marker: "CortexGraph";
+    };
+    readonly rel: {
+        readonly belongsTo: "BELONGS_TO";
+        readonly specializes: "SPECIALIZES";
+        readonly queriedVia: "QUERIED_VIA";
+        readonly mutatedVia: "MUTATED_VIA";
+        readonly returns: "RETURNS";
+        readonly dependsOn: "DEPENDS_ON";
+        readonly governs: "GOVERNS";
+        readonly requestedVia: "REQUESTED_VIA";
+    };
+    readonly prop: {
+        readonly name: "name";
+        readonly description: "description";
+        readonly aliases: "aliases";
+        readonly metadata: "metadata";
+        readonly path: "path";
+        readonly method: "method";
+        readonly params: "params";
+        readonly body: "body";
+        readonly response: "response";
+        readonly propertiesDescriptions: "propertiesDescriptions";
+        readonly successStatus: "successStatus";
+        readonly errorStatuses: "errorStatuses";
+        readonly builtInId: "builtInId";
+        readonly embedding: "embedding";
+        /** On a RETURNS edge: which part of the response carries the concept. */
+        readonly field: "field";
+        /** On a DEPENDS_ON edge. */
+        readonly paramName: "paramName";
+        readonly fromField: "fromField";
+        /** On the marker node. */
+        readonly version: "version";
+    };
+    /** Created by the CLI's seeder, queried by name in the resolver's first hop. */
+    readonly conceptEmbeddingsIndex: "concept_embeddings";
+};
+export type GraphSchema = typeof GRAPH_SCHEMA;

package/dist/{src → contracts}/graph/types.d.ts

@@ -10,7 +10,7 @@ export type EndpointScalarType = "uuid" | "number" | "date" | "datetime" | "stri
 export type EndpointProperty = {
     readonly name: string;
     readonly required: boolean;
-    readonly type: EndpointScalarType | string;
+    readonly type: EndpointScalarType | (string & NonNullable<unknown>);
     readonly isArray?: boolean;
     readonly properties?: readonly EndpointProperty[];
     readonly description?: string;

package/dist/contracts/graph.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The graph contract — the knowledge-graph vocabulary, authoring types and
+ * clients that `@m6d/cortex-cli` writes with and `@m6d/cortex-server` reads
+ * with. `@m6d/cortex-server` re-exports all of it, so a project authoring
+ * domains still has exactly one import path.
+ */
+export type { GraphSchema } from "./graph/schema";
+export { GRAPH_SCHEMA, GRAPH_SCHEMA_VERSION } from "./graph/schema";
+export type { EndpointScalarType, EndpointProperty, ResponseKind, AutoGenerated, ConceptDef, EndpointDef, EndpointInput, ServiceDef, RuleDef, DomainDef, } from "./graph/types";
+export { defineConcept, defineRule, defineService, defineDomain, defineEndpoint, } from "./graph/helpers";
+export type { Neo4jConfig, Neo4jClient } from "./graph/neo4j";
+export { createNeo4jClient } from "./graph/neo4j";
+export type { EmbedFn, EmbeddingProviderConfig } from "./graph/embed";
+export { createEmbedder } from "./graph/embed";

package/dist/contracts/runtime.d.ts

@@ -0,0 +1,278 @@
+import { z } from "zod";
+/** Runtime contract §1.1: the `:id` path param, validated on both sides of the wire. */
+export declare const AGENT_SLUG_PATTERN: RegExp;
+/** Runtime contract §5: tool names become `tools.<name>()` sandbox bindings. */
+export declare const TOOL_NAME_PATTERN: RegExp;
+export declare const PROMPT_VARIABLES: readonly ["userName", "channel", "locale"];
+export declare const RUNTIME_ERROR_KINDS: readonly ["timeout", "upstream_4xx", "upstream_5xx", "schema_mismatch", "rate_limited", "not_found", "unauthorized", "invalid_request", "egress_blocked", "internal"];
+/** The ways an execute output may disagree with the tool's declared schema. */
+export declare const JSON_SCHEMA_ISSUE_KINDS: readonly ["missing", "unexpected", "type_mismatch"];
+export declare const agentSlugSchema: z.ZodString;
+export declare const localeSchema: z.ZodEnum<{
+    en: "en";
+    ar: "ar";
+}>;
+export declare const catalogVersionSchema: z.ZodString;
+export declare const sharedShapeSchema: z.ZodObject<{
+    ref: z.ZodString;
+    shape: z.ZodString;
+}, z.core.$strip>;
+export declare const knowledgeChunkSchema: z.ZodObject<{
+    chunkId: z.ZodUUID;
+    text: z.ZodString;
+    score: z.ZodNumber;
+    citation: z.ZodObject<{
+        documentId: z.ZodUUID;
+        documentTitle: z.ZodString;
+        page: z.ZodNullable<z.ZodNumber>;
+        section: z.ZodNullable<z.ZodString>;
+        uri: z.ZodNullable<z.ZodURL>;
+        service: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const toolSignatureSchema: z.ZodObject<{
+    toolId: z.ZodUUID;
+    name: z.ZodString;
+    version: z.ZodNumber;
+    readOnly: z.ZodBoolean;
+    tags: z.ZodArray<z.ZodString>;
+    signature: z.ZodString;
+    score: z.ZodNullable<z.ZodNumber>;
+    pinned: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const serviceCardSchema: z.ZodObject<{
+    serviceId: z.ZodUUID;
+    key: z.ZodString;
+    name: z.ZodString;
+    card: z.ZodString;
+    score: z.ZodNumber;
+}, z.core.$strip>;
+export declare const runtimeAgentConfigSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    systemPrompt: z.ZodString;
+    promptVariables: z.ZodArray<z.ZodEnum<{
+        userName: "userName";
+        channel: "channel";
+        locale: "locale";
+    }>>;
+    catalogBlurb: z.ZodString;
+    defaultLocale: z.ZodEnum<{
+        en: "en";
+        ar: "ar";
+    }>;
+    metaTools: z.ZodObject<{
+        searchKnowledge: z.ZodBoolean;
+        searchTools: z.ZodBoolean;
+        searchServices: z.ZodBoolean;
+    }, z.core.$strip>;
+    limits: z.ZodObject<{
+        resolveTokenBudget: z.ZodNumber;
+        executeTimeoutMs: z.ZodNumber;
+        maxResponseBytes: z.ZodNumber;
+    }, z.core.$strip>;
+    catalogVersion: z.ZodString;
+    publishedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export declare const resolveRequestSchema: z.ZodObject<{
+    query: z.ZodString;
+    locale: z.ZodOptional<z.ZodEnum<{
+        en: "en";
+        ar: "ar";
+    }>>;
+    hints: z.ZodOptional<z.ZodObject<{
+        threadId: z.ZodOptional<z.ZodString>;
+        recentToolNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        turnIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    tokenBudget: z.ZodOptional<z.ZodNumber>;
+    limits: z.ZodOptional<z.ZodObject<{
+        knowledge: z.ZodDefault<z.ZodNumber>;
+        tools: z.ZodDefault<z.ZodNumber>;
+        services: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const resolveResponseSchema: z.ZodObject<{
+    resolveId: z.ZodUUID;
+    catalogVersion: z.ZodString;
+    locale: z.ZodEnum<{
+        en: "en";
+        ar: "ar";
+    }>;
+    knowledge: z.ZodArray<z.ZodObject<{
+        chunkId: z.ZodUUID;
+        text: z.ZodString;
+        score: z.ZodNumber;
+        citation: z.ZodObject<{
+            documentId: z.ZodUUID;
+            documentTitle: z.ZodString;
+            page: z.ZodNullable<z.ZodNumber>;
+            section: z.ZodNullable<z.ZodString>;
+            uri: z.ZodNullable<z.ZodURL>;
+            service: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    tools: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodUUID;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        readOnly: z.ZodBoolean;
+        tags: z.ZodArray<z.ZodString>;
+        signature: z.ZodString;
+        score: z.ZodNullable<z.ZodNumber>;
+        pinned: z.ZodBoolean;
+    }, z.core.$strip>>;
+    services: z.ZodArray<z.ZodObject<{
+        serviceId: z.ZodUUID;
+        key: z.ZodString;
+        name: z.ZodString;
+        card: z.ZodString;
+        score: z.ZodNumber;
+    }, z.core.$strip>>;
+    sharedShapes: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        shape: z.ZodString;
+    }, z.core.$strip>>;
+    budget: z.ZodObject<{
+        requested: z.ZodNumber;
+        used: z.ZodNumber;
+        truncated: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const searchRequestSchema: z.ZodObject<{
+    query: z.ZodString;
+    limit: z.ZodDefault<z.ZodNumber>;
+    locale: z.ZodOptional<z.ZodEnum<{
+        en: "en";
+        ar: "ar";
+    }>>;
+    threadId: z.ZodOptional<z.ZodString>;
+    service: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const searchToolsResponseSchema: z.ZodObject<{
+    catalogVersion: z.ZodString;
+    tools: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodUUID;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        readOnly: z.ZodBoolean;
+        tags: z.ZodArray<z.ZodString>;
+        signature: z.ZodString;
+        score: z.ZodNullable<z.ZodNumber>;
+        pinned: z.ZodBoolean;
+    }, z.core.$strip>>;
+    sharedShapes: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        shape: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const searchServicesResponseSchema: z.ZodObject<{
+    catalogVersion: z.ZodString;
+    services: z.ZodArray<z.ZodObject<{
+        serviceId: z.ZodUUID;
+        key: z.ZodString;
+        name: z.ZodString;
+        card: z.ZodString;
+        score: z.ZodNumber;
+    }, z.core.$strip>>;
+    tools: z.ZodArray<z.ZodObject<{
+        toolId: z.ZodUUID;
+        name: z.ZodString;
+        version: z.ZodNumber;
+        readOnly: z.ZodBoolean;
+        tags: z.ZodArray<z.ZodString>;
+        signature: z.ZodString;
+        score: z.ZodNullable<z.ZodNumber>;
+        pinned: z.ZodBoolean;
+    }, z.core.$strip>>;
+    sharedShapes: z.ZodArray<z.ZodObject<{
+        ref: z.ZodString;
+        shape: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const searchKnowledgeResponseSchema: z.ZodObject<{
+    catalogVersion: z.ZodString;
+    knowledge: z.ZodArray<z.ZodObject<{
+        chunkId: z.ZodUUID;
+        text: z.ZodString;
+        score: z.ZodNumber;
+        citation: z.ZodObject<{
+            documentId: z.ZodUUID;
+            documentTitle: z.ZodString;
+            page: z.ZodNullable<z.ZodNumber>;
+            section: z.ZodNullable<z.ZodString>;
+            uri: z.ZodNullable<z.ZodURL>;
+            service: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const executeRequestSchema: z.ZodObject<{
+    input: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    context: z.ZodOptional<z.ZodObject<{
+        threadId: z.ZodOptional<z.ZodString>;
+        userId: z.ZodOptional<z.ZodString>;
+        locale: z.ZodOptional<z.ZodEnum<{
+            en: "en";
+            ar: "ar";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const executeResponseSchema: z.ZodObject<{
+    toolId: z.ZodUUID;
+    name: z.ZodString;
+    version: z.ZodNumber;
+    output: z.ZodUnknown;
+    meta: z.ZodObject<{
+        upstreamStatus: z.ZodNumber;
+        durationMs: z.ZodNumber;
+        replayed: z.ZodBoolean;
+        truncated: z.ZodBoolean;
+        truncatedPaths: z.ZodArray<z.ZodString>;
+        drift: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                missing: "missing";
+                unexpected: "unexpected";
+                type_mismatch: "type_mismatch";
+            }>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const runtimeErrorKindSchema: z.ZodEnum<{
+    timeout: "timeout";
+    upstream_4xx: "upstream_4xx";
+    upstream_5xx: "upstream_5xx";
+    schema_mismatch: "schema_mismatch";
+    rate_limited: "rate_limited";
+    not_found: "not_found";
+    unauthorized: "unauthorized";
+    invalid_request: "invalid_request";
+    egress_blocked: "egress_blocked";
+    internal: "internal";
+}>;
+export type RuntimeErrorKind = z.infer<typeof runtimeErrorKindSchema>;
+export declare const runtimeErrorSchema: z.ZodObject<{
+    error: z.ZodObject<{
+        kind: z.ZodEnum<{
+            timeout: "timeout";
+            upstream_4xx: "upstream_4xx";
+            upstream_5xx: "upstream_5xx";
+            schema_mismatch: "schema_mismatch";
+            rate_limited: "rate_limited";
+            not_found: "not_found";
+            unauthorized: "unauthorized";
+            invalid_request: "invalid_request";
+            egress_blocked: "egress_blocked";
+            internal: "internal";
+        }>;
+        detail: z.ZodString;
+        retryable: z.ZodBoolean;
+        retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
+        upstreamStatus: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type RuntimeAgentConfig = z.infer<typeof runtimeAgentConfigSchema>;
+export type ResolveRequest = z.input<typeof resolveRequestSchema>;
+export type ResolveResponse = z.infer<typeof resolveResponseSchema>;
+export type SearchRequest = z.input<typeof searchRequestSchema>;
+export type ExecuteRequest = z.input<typeof executeRequestSchema>;
+export {};