@independo/inderun-contracts 0.1.0

package/dist/generated/schemas.d.ts

@@ -0,0 +1,610 @@
+export declare const taskRequestSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/task-request.schema.json";
+    readonly title: "TaskRequest";
+    readonly description: "The standard request payload for initiating a text-to-text execution task within the IndeRun framework.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["schemaVersion", "task"];
+    readonly anyOf: readonly [{
+        readonly required: readonly ["prompt"];
+    }, {
+        readonly required: readonly ["messages"];
+    }];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly description: "Contract schema version used to interpret the request payload.";
+            readonly const: "1.0";
+        };
+        readonly requestId: {
+            readonly description: "Optional identifier for tracking or correlating this specific execution attempt.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly task: {
+            readonly description: "A descriptor specifying the type of work to be performed. For text-to-text, the kind must be 'text_to_text'.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["kind"];
+            readonly properties: {
+                readonly kind: {
+                    readonly description: "The standard task category. Currently supports 'text_to_text' for prompt-based interactions.";
+                    readonly const: "text_to_text";
+                };
+            };
+        };
+        readonly prompt: {
+            readonly description: "A simple, single-turn text prompt used to trigger a response from the AI model.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly messages: {
+            readonly description: "A list of interaction messages for multi-turn conversation or chat-style execution.";
+            readonly type: "array";
+            readonly minItems: 1;
+            readonly items: {
+                readonly description: "An individual message in a conversation.";
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["role", "content"];
+                readonly properties: {
+                    readonly role: {
+                        readonly description: "The role of the author (e.g., 'user', 'assistant').";
+                        readonly enum: readonly ["system", "user", "assistant"];
+                    };
+                    readonly content: {
+                        readonly description: "The actual text content of the message.";
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                };
+            };
+        };
+        readonly generation: {
+            readonly description: "Optional configuration for fine-tuning how the AI model generates its response.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly maxOutputTokens: {
+                    readonly description: "The maximum number of tokens to generate in a single response.";
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+                readonly temperature: {
+                    readonly description: "Controls the randomness of the output. Range: 0 (most deterministic) to 2 (highest variance).";
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly maximum: 2;
+                };
+                readonly topP: {
+                    readonly description: "Nucleus sampling parameter for controlling diversity vs focus in the output.";
+                    readonly type: "number";
+                    readonly minimum: 0;
+                    readonly maximum: 1;
+                };
+                readonly seed: {
+                    readonly description: "A fixed seed for deterministic generation (where supported by the underlying provider).";
+                    readonly type: "integer";
+                };
+                readonly stop: {
+                    readonly description: "Sequence tokens that should terminate the generation process.";
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly constraints: {
+            readonly description: "Request-level routing constraints used by the planner.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly privacy: {
+                    readonly description: "Privacy requirement or preference for execution placement.";
+                    readonly enum: readonly ["local_required", "local_preferred", "cloud_allowed", "cloud_required"];
+                };
+                readonly cloud: {
+                    readonly description: "Cloud execution constraint.";
+                    readonly enum: readonly ["forbidden", "allowed", "required"];
+                };
+                readonly timeoutMs: {
+                    readonly description: "Optional routing timeout budget in milliseconds.";
+                    readonly type: "integer";
+                    readonly minimum: 1;
+                };
+            };
+        };
+        readonly preferences: {
+            readonly description: "Soft routing preferences used for deterministic provider ordering.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly optimizeFor: {
+                    readonly description: "Primary optimization goal when multiple providers remain eligible.";
+                    readonly enum: readonly ["privacy", "latency", "cost", "balanced"];
+                };
+            };
+        };
+        readonly telemetry: {
+            readonly description: "Execution preferences for tracking usage and performance metrics.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly consent: {
+                    readonly description: "Whether the user consents to telemetry collection for this specific request.";
+                    readonly type: "boolean";
+                };
+                readonly level: {
+                    readonly description: "The granularity of the collected metrics (off, minimal, or debug).";
+                    readonly enum: readonly ["off", "minimal", "debug"];
+                };
+                readonly tags: {
+                    readonly description: "Optional key-value pairs for correlating telemetry data with specific features or users.";
+                    readonly type: "object";
+                    readonly additionalProperties: {
+                        readonly type: "string";
+                    };
+                };
+            };
+        };
+        readonly authContextRef: {
+            readonly description: "A unique identifier used to retrieve credentials from a secure local storage. Raw sensitive keys (API keys, etc.) should NEVER be placed directly in the request payload.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+    };
+};
+export declare const taskResultSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/task-result.schema.json";
+    readonly title: "TaskResult";
+    readonly description: "The standard response payload for completed text-to-text execution within the IndeRun framework.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["schemaVersion", "runId", "output", "finishReason", "telemetry"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly description: "Contract schema version used to interpret the result payload.";
+            readonly const: "1.0";
+        };
+        readonly runId: {
+            readonly description: "A unique, opaque identifier assigned by the engine for this specific execution attempt.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly output: {
+            readonly description: "The normalized content returned from the selected provider.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["type", "text"];
+            readonly properties: {
+                readonly type: {
+                    readonly description: "Output payload category (e.g., 'text' for Mode 1 text-to-text).";
+                    readonly const: "text";
+                };
+                readonly text: {
+                    readonly description: "The actual text generated by the execution.";
+                    readonly type: "string";
+                };
+            };
+        };
+        readonly finishReason: {
+            readonly description: "Standardized reason describing how generation concluded (e.g., 'stop', 'length', 'cancelled', or 'error').";
+            readonly enum: readonly ["stop", "length", "cancelled", "error"];
+        };
+        readonly usage: {
+            readonly description: "Optional metadata regarding the quantity of tokens processed by the provider.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly inputTokens: {
+                    readonly description: "Number of input tokens consumed, as reported by the provider.";
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly outputTokens: {
+                    readonly description: "Number of output tokens generated, as reported by the provider.";
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+                readonly totalTokens: {
+                    readonly description: "Aggregated token count for this request, as reported by the provider.";
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                };
+            };
+        };
+        readonly telemetry: {
+            readonly description: "Required metadata providing an overview of the execution result and performance metrics.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["providerUsed", "totalMs"];
+            readonly properties: {
+                readonly providerUsed: {
+                    readonly description: "The identifier for the specific provider that handled the request (e.g., 'openai_compatible_cloud').";
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly totalMs: {
+                    readonly description: "Measured execution duration in milliseconds, including route selection and result processing.";
+                    readonly type: "number";
+                    readonly minimum: 0;
+                };
+                readonly errorClass: {
+                    readonly description: "Included if the request resulted in a provider-level error (e.g., 'CapabilityMismatch' or 'Unavailable').";
+                    readonly enum: readonly ["CapabilityMismatch", "Offline", "AuthError", "RateLimited", "Timeout", "Unavailable", "Internal"];
+                };
+            };
+        };
+    };
+};
+export declare const inderunErrorSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/inderun-error.schema.json";
+    readonly title: "IndeRunError";
+    readonly description: "Normalized Milestone-1 error contract.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["schemaVersion", "errorClass", "message"];
+    readonly properties: {
+        readonly schemaVersion: {
+            readonly description: "Contract schema version used to interpret the error payload.";
+            readonly const: "1.0";
+        };
+        readonly errorClass: {
+            readonly description: "Normalized error taxonomy class.";
+            readonly enum: readonly ["CapabilityMismatch", "Offline", "AuthError", "RateLimited", "Timeout", "Unavailable", "Internal"];
+        };
+        readonly message: {
+            readonly description: "Human-readable error message suitable for logs and developer diagnostics.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly runId: {
+            readonly description: "Opaque run identifier associated with the failed execution, if available.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly providerId: {
+            readonly description: "Identifier of the provider associated with the failure, if execution reached a provider.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly retryable: {
+            readonly description: "Whether retrying the same request may succeed.";
+            readonly type: "boolean";
+        };
+        readonly retryAfterMs: {
+            readonly description: "Optional suggested delay before retrying, in milliseconds.";
+            readonly type: "integer";
+            readonly minimum: 0;
+        };
+        readonly details: {
+            readonly description: "Optional structured diagnostic details. It must not contain raw secrets.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+    };
+};
+export declare const httpRequestSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/http-request.schema.json";
+    readonly title: "HttpRequest";
+    readonly description: "Normalized HTTP request payload for host-provided cloud transport.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["method", "url"];
+    readonly properties: {
+        readonly method: {
+            readonly description: "HTTP method to use for the request.";
+            readonly enum: readonly ["GET", "POST", "PUT", "DELETE", "PATCH"];
+        };
+        readonly url: {
+            readonly description: "Absolute target URL for the provider transport request.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly headers: {
+            readonly description: "HTTP headers to send after the provider adapter has applied any required transport-level credentials.";
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
+        readonly body: {
+            readonly description: "Optional serialized request body. For JSON APIs this should be a JSON string.";
+            readonly type: "string";
+        };
+        readonly timeoutMs: {
+            readonly description: "Optional maximum duration for the host transport attempt in milliseconds.";
+            readonly type: "integer";
+            readonly minimum: 1;
+        };
+    };
+};
+export declare const httpResponseSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/http-response.schema.json";
+    readonly title: "HttpResponse";
+    readonly description: "Normalized HTTP response payload returned by host-provided cloud transport.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["status", "statusText", "headers", "body"];
+    readonly properties: {
+        readonly status: {
+            readonly description: "HTTP status code returned by the provider transport.";
+            readonly type: "integer";
+            readonly minimum: 100;
+            readonly maximum: 599;
+        };
+        readonly statusText: {
+            readonly description: "HTTP status text returned by the provider transport.";
+            readonly type: "string";
+        };
+        readonly headers: {
+            readonly description: "HTTP response headers normalized to string key-value pairs.";
+            readonly type: "object";
+            readonly additionalProperties: {
+                readonly type: "string";
+            };
+        };
+        readonly body: {
+            readonly description: "Serialized response body returned by the provider transport.";
+            readonly type: "string";
+        };
+    };
+};
+export declare const telemetryEventSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/telemetry-event.schema.json";
+    readonly title: "TelemetryEvent";
+    readonly description: "Normalized telemetry event emitted by the orchestrator and providers.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["type", "runId", "timestamp", "payload"];
+    readonly properties: {
+        readonly type: {
+            readonly description: "Telemetry event kind emitted by the orchestrator or provider integration.";
+            readonly enum: readonly ["route_decided", "attempt_succeeded", "attempt_failed"];
+        };
+        readonly runId: {
+            readonly description: "Opaque run identifier associated with this execution event.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly timestamp: {
+            readonly description: "Wall-clock event timestamp in Unix epoch milliseconds.";
+            readonly type: "number";
+            readonly minimum: 0;
+        };
+        readonly payload: {
+            readonly description: "Event-specific metadata. It must not contain prompt payloads or raw secrets.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+        };
+    };
+};
+export declare const routePlannerInputSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/route-planner-input.schema.json";
+    readonly title: "RoutePlannerInput";
+    readonly description: "Pure data input contract for deterministic shared-core Mode-1 route planning.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["task", "constraints", "preferences", "providers"];
+    readonly properties: {
+        readonly task: {
+            readonly description: "Minimal task descriptor for provider task matching.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["kind"];
+            readonly properties: {
+                readonly kind: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
+        readonly constraints: {
+            readonly description: "Hard routing constraints evaluated before provider selection.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly privacy: {
+                    readonly description: "Privacy requirement or preference for execution placement.";
+                    readonly enum: readonly ["local_required", "local_preferred", "cloud_allowed", "cloud_required"];
+                };
+                readonly cloud: {
+                    readonly description: "Cloud execution constraint.";
+                    readonly enum: readonly ["forbidden", "allowed", "required"];
+                };
+                readonly networkOnline: {
+                    readonly description: "Current connectivity snapshot used for cloud route planning.";
+                    readonly type: "boolean";
+                };
+            };
+        };
+        readonly preferences: {
+            readonly description: "Soft route ordering preferences applied after hard filtering.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly properties: {
+                readonly optimizeFor: {
+                    readonly description: "Primary optimization goal when multiple providers remain eligible.";
+                    readonly enum: readonly ["privacy", "latency", "cost", "balanced"];
+                };
+            };
+        };
+        readonly providers: {
+            readonly description: "Static descriptors plus dynamic capability snapshots for planning.";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["descriptor", "capabilities"];
+                readonly properties: {
+                    readonly descriptor: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                        readonly required: readonly ["id", "type", "supports", "tasks"];
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                            readonly type: {
+                                readonly enum: readonly ["local", "edge", "cloud"];
+                            };
+                            readonly supports: {
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                                readonly required: readonly ["run"];
+                                readonly properties: {
+                                    readonly run: {
+                                        readonly type: "boolean";
+                                    };
+                                };
+                            };
+                            readonly tasks: {
+                                readonly type: "array";
+                                readonly items: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                            readonly privacy: {
+                                readonly description: "Descriptor privacy metadata used to enforce local/cloud routing rules.";
+                                readonly type: "object";
+                                readonly additionalProperties: true;
+                                readonly required: readonly ["dataLeavesDevice"];
+                                readonly properties: {
+                                    readonly dataLeavesDevice: {
+                                        readonly type: "boolean";
+                                    };
+                                    readonly regions: {
+                                        readonly type: "array";
+                                        readonly items: {
+                                            readonly type: "string";
+                                            readonly minLength: 1;
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    readonly capabilities: {
+                        readonly type: "object";
+                        readonly additionalProperties: true;
+                        readonly required: readonly ["available"];
+                        readonly properties: {
+                            readonly available: {
+                                readonly type: "boolean";
+                            };
+                            readonly reason: {
+                                readonly type: "string";
+                                readonly minLength: 1;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export declare const routePlanSchema: {
+    readonly $schema: "https://json-schema.org/draft/2020-12/schema";
+    readonly $id: "https://schemas.inderun.dev/1.0/route-plan.schema.json";
+    readonly title: "RoutePlan";
+    readonly description: "Deterministic shared-core Mode-1 route planning result.";
+    readonly type: "object";
+    readonly additionalProperties: true;
+    readonly required: readonly ["fallbackProviderIds", "candidates", "rejectedProviders", "explanation"];
+    readonly properties: {
+        readonly selectedProviderId: {
+            readonly description: "Chosen primary provider ID, if any.";
+            readonly type: "string";
+            readonly minLength: 1;
+        };
+        readonly fallbackProviderIds: {
+            readonly description: "Fallback provider IDs ordered after the primary selection.";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "string";
+                readonly minLength: 1;
+            };
+        };
+        readonly candidates: {
+            readonly description: "Eligible candidates in deterministic order.";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["providerId", "order"];
+                readonly properties: {
+                    readonly providerId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly order: {
+                        readonly type: "integer";
+                        readonly minimum: 0;
+                    };
+                };
+            };
+        };
+        readonly rejectedProviders: {
+            readonly description: "Providers filtered out during planning together with machine-readable reasons.";
+            readonly type: "array";
+            readonly items: {
+                readonly type: "object";
+                readonly additionalProperties: true;
+                readonly required: readonly ["providerId", "reasons"];
+                readonly properties: {
+                    readonly providerId: {
+                        readonly type: "string";
+                        readonly minLength: 1;
+                    };
+                    readonly reasons: {
+                        readonly type: "array";
+                        readonly items: {
+                            readonly type: "object";
+                            readonly additionalProperties: true;
+                            readonly required: readonly ["code", "message"];
+                            readonly properties: {
+                                readonly code: {
+                                    readonly enum: readonly ["task_not_supported", "run_not_supported", "privacy_constraint", "cloud_constraint", "offline", "capability_unavailable"];
+                                };
+                                readonly message: {
+                                    readonly type: "string";
+                                    readonly minLength: 1;
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+        readonly failureCode: {
+            readonly description: "Normalized routing failure class when no provider is selected.";
+            readonly enum: readonly ["capability_mismatch", "offline", "unavailable"];
+        };
+        readonly explanation: {
+            readonly description: "Human-readable selection or failure explanation suitable for telemetry/debugging.";
+            readonly type: "object";
+            readonly additionalProperties: true;
+            readonly required: readonly ["summary"];
+            readonly properties: {
+                readonly summary: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+                readonly selectedProviderId: {
+                    readonly type: "string";
+                    readonly minLength: 1;
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=schemas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/generated/schemas.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiMpB,CAAC;AAEX,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4GnB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2DrB,CAAC;AAEX,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4CpB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCrB,CAAC;AAEX,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCvB,CAAC;AAEX,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqK1B,CAAC;AAEX,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyHlB,CAAC"}