pi-harness-runtime 0.10.11 → 0.10.12

package/packages/provider-adapter-sdk/dist/src/builder.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Provider Adapter SDK - Builder
+ *
+ * Fluent API for creating provider adapters.
+ */
+import type { ProviderCapability, ProviderRequest } from "../../types/src/runtime-types.js";
+import type { AdapterResult, AdapterBuilderConfig, ErrorAnalysis, HealthCheckResult, InvokeFunction, ErrorParserFunction, HealthCheckFunction, RateLimitConfig } from "./types.js";
+/**
+ * Builder class for creating provider adapters
+ */
+export declare class AdapterBuilder {
+    private _id;
+    private _name;
+    private _models;
+    private _capabilities;
+    private _rateLimits;
+    private _defaultModel;
+    private _maxTokens;
+    private _invokeFn;
+    private _errorParserFn;
+    private _healthCheckFn;
+    constructor(name?: string);
+    /**
+     * Set the adapter ID
+     */
+    id(id: string): AdapterBuilder;
+    /**
+     * Set the adapter name
+     */
+    name(name: string): AdapterBuilder;
+    /**
+     * Set supported models
+     */
+    models(...models: string[]): AdapterBuilder;
+    /**
+     * Set default model (if different from first model)
+     */
+    defaultModel(model: string): AdapterBuilder;
+    /**
+     * Set capabilities
+     */
+    capabilities(...capabilities: ProviderCapability[]): AdapterBuilder;
+    /**
+     * Set rate limits
+     */
+    rateLimits(limits: RateLimitConfig): AdapterBuilder;
+    /**
+     * Set token limits per model
+     */
+    maxTokens(model: string, tokens: number): AdapterBuilder;
+    /**
+     * Set the invoke function (required)
+     */
+    invoke(fn: InvokeFunction): AdapterBuilder;
+    /**
+     * Set custom error parser
+     */
+    parseError(fn: ErrorParserFunction): AdapterBuilder;
+    /**
+     * Set health check function
+     */
+    healthCheck(fn: HealthCheckFunction): AdapterBuilder;
+    /**
+     * Validate and build the adapter
+     */
+    build(): BuiltAdapter;
+}
+/**
+ * Configuration for BuiltAdapter
+ */
+interface BuiltAdapterConfig {
+    id: string;
+    name: string;
+    models: string[];
+    capabilities: ProviderCapability[];
+    rateLimits: RateLimitConfig;
+    defaultModel: string;
+    maxTokens: Record<string, number>;
+    invokeFn: InvokeFunction;
+    errorParserFn: ErrorParserFunction;
+    healthCheckFn?: HealthCheckFunction;
+}
+/**
+ * Built adapter instance
+ */
+export declare class BuiltAdapter {
+    readonly id: string;
+    readonly name: string;
+    private readonly _models;
+    private readonly _capabilities;
+    private readonly _rateLimits;
+    private readonly _defaultModel;
+    private readonly _maxTokens;
+    private readonly _invokeFn;
+    private readonly _errorParserFn;
+    private readonly _healthCheckFn?;
+    constructor(config: BuiltAdapterConfig);
+    /**
+     * Get supported models
+     */
+    getModels(): string[];
+    /**
+     * Get capabilities
+     */
+    getCapabilities(): ProviderCapability[];
+    /**
+     * Get rate limits
+     */
+    getRateLimits(): RateLimitConfig;
+    /**
+     * Check if model is supported
+     */
+    supportsModel(model: string): boolean;
+    /**
+     * Get default model
+     */
+    getDefaultModel(): string;
+    /**
+     * Get max tokens for a model
+     */
+    getMaxTokens(model?: string): number;
+    /**
+     * Invoke the adapter
+     */
+    invoke(request: ProviderRequest): Promise<AdapterResult>;
+    /**
+     * Parse an error
+     */
+    parseError(error: unknown): ErrorAnalysis;
+    /**
+     * Health check
+     */
+    healthCheck(): Promise<HealthCheckResult>;
+    /**
+     * Convert to adapter info for registry
+     */
+    toConfig(): AdapterBuilderConfig;
+}
+export {};
+//# sourceMappingURL=builder.d.ts.map

package/packages/provider-adapter-sdk/dist/src/builder.js

@@ -0,0 +1,332 @@
+/**
+ * Provider Adapter SDK - Builder
+ *
+ * Fluent API for creating provider adapters.
+ */
+import { BuilderValidationError } from "./errors.js";
+/**
+ * Token limits for common model families
+ */
+const DEFAULT_TOKEN_LIMITS = {
+    // MiniMax
+    "minimax/MiniMax-M3": 32768,
+    "minimax/MiniMax-Text-01": 1000000,
+    // Anthropic
+    "anthropic/claude-3-5-sonnet": 200000,
+    "anthropic/claude-3-5-haiku": 200000,
+    "anthropic/claude-3-opus": 200000,
+    "anthropic/claude-3-sonnet": 200000,
+    "anthropic/claude-3-haiku": 200000,
+    "anthropic/claude-2.1": 200000,
+    "anthropic/claude-2": 100000,
+    "anthropic/claude-instant": 100000,
+    // OpenAI
+    "openai/gpt-4o": 128000,
+    "openai/gpt-4-turbo": 128000,
+    "openai/gpt-4": 128000,
+    "openai/gpt-3.5-turbo": 16385,
+    // Google
+    "google/gemini-1.5-pro": 128000,
+    "google/gemini-1.5-flash": 128000,
+    // Default
+    default: 4096,
+};
+/**
+ * Default error parser for unknown providers
+ */
+const defaultErrorParser = (error) => {
+    const e = error;
+    const msg = String(e.message ?? e.error ?? "").toLowerCase();
+    const code = String(e.code ?? "");
+    return {
+        quotaExceeded: code === "insufficient_quota" ||
+            code === "context_length_exceeded" ||
+            msg.includes("quota"),
+        rateLimited: code === "rate_limit_exceeded" ||
+            msg.includes("429") ||
+            msg.includes("rate limit"),
+        timeout: msg.includes("timeout") || msg.includes("timed out"),
+        serverError: code.startsWith("5") || msg.includes("500"),
+        clientError: code.startsWith("4") && !code.startsWith("429"),
+        message: String(e.message ?? e.error ?? "Unknown error"),
+        code,
+    };
+};
+/**
+ * Builder class for creating provider adapters
+ */
+export class AdapterBuilder {
+    _id;
+    _name;
+    _models = [];
+    _capabilities = [];
+    _rateLimits = {};
+    _defaultModel;
+    _maxTokens = {};
+    _invokeFn;
+    _errorParserFn = defaultErrorParser;
+    _healthCheckFn;
+    constructor(name) {
+        if (name) {
+            this._name = name;
+        }
+    }
+    /**
+     * Set the adapter ID
+     */
+    id(id) {
+        if (!id || id.trim() === "") {
+            throw new BuilderValidationError("Adapter ID cannot be empty", "id");
+        }
+        this._id = id.toLowerCase();
+        return this;
+    }
+    /**
+     * Set the adapter name
+     */
+    name(name) {
+        if (!name || name.trim() === "") {
+            throw new BuilderValidationError("Adapter name cannot be empty", "name");
+        }
+        this._name = name;
+        return this;
+    }
+    /**
+     * Set supported models
+     */
+    models(...models) {
+        if (models.length === 0) {
+            throw new BuilderValidationError("At least one model must be specified", "models");
+        }
+        this._models = models;
+        if (!this._defaultModel) {
+            this._defaultModel = models[0];
+        }
+        return this;
+    }
+    /**
+     * Set default model (if different from first model)
+     */
+    defaultModel(model) {
+        if (!this._models.includes(model)) {
+            throw new BuilderValidationError(`Default model '${model}' must be in the models list`, "defaultModel");
+        }
+        this._defaultModel = model;
+        return this;
+    }
+    /**
+     * Set capabilities
+     */
+    capabilities(...capabilities) {
+        this._capabilities = capabilities;
+        return this;
+    }
+    /**
+     * Set rate limits
+     */
+    rateLimits(limits) {
+        this._rateLimits = limits;
+        return this;
+    }
+    /**
+     * Set token limits per model
+     */
+    maxTokens(model, tokens) {
+        this._maxTokens[model] = tokens;
+        return this;
+    }
+    /**
+     * Set the invoke function (required)
+     */
+    invoke(fn) {
+        if (typeof fn !== "function") {
+            throw new BuilderValidationError("Invoke must be a function", "invoke");
+        }
+        this._invokeFn = fn;
+        return this;
+    }
+    /**
+     * Set custom error parser
+     */
+    parseError(fn) {
+        if (typeof fn !== "function") {
+            throw new BuilderValidationError("parseError must be a function", "parseError");
+        }
+        this._errorParserFn = fn;
+        return this;
+    }
+    /**
+     * Set health check function
+     */
+    healthCheck(fn) {
+        if (typeof fn !== "function") {
+            throw new BuilderValidationError("healthCheck must be a function", "healthCheck");
+        }
+        this._healthCheckFn = fn;
+        return this;
+    }
+    /**
+     * Validate and build the adapter
+     */
+    build() {
+        // Validate required fields
+        if (!this._id) {
+            throw new BuilderValidationError("Adapter ID is required", "id");
+        }
+        if (!this._name) {
+            throw new BuilderValidationError("Adapter name is required", "name");
+        }
+        if (!this._invokeFn) {
+            throw new BuilderValidationError("Invoke function is required", "invoke");
+        }
+        return new BuiltAdapter({
+            id: this._id,
+            name: this._name,
+            models: this._models,
+            capabilities: this._capabilities,
+            rateLimits: this._rateLimits,
+            defaultModel: this._defaultModel ?? this._models[0],
+            maxTokens: { ...DEFAULT_TOKEN_LIMITS, ...this._maxTokens },
+            invokeFn: this._invokeFn,
+            errorParserFn: this._errorParserFn,
+            healthCheckFn: this._healthCheckFn,
+        });
+    }
+}
+/**
+ * Built adapter instance
+ */
+export class BuiltAdapter {
+    id;
+    name;
+    _models;
+    _capabilities;
+    _rateLimits;
+    _defaultModel;
+    _maxTokens;
+    _invokeFn;
+    _errorParserFn;
+    _healthCheckFn;
+    constructor(config) {
+        this.id = config.id;
+        this.name = config.name;
+        this._models = config.models;
+        this._capabilities = config.capabilities;
+        this._rateLimits = config.rateLimits;
+        this._defaultModel = config.defaultModel;
+        this._maxTokens = config.maxTokens;
+        this._invokeFn = config.invokeFn;
+        this._errorParserFn = config.errorParserFn;
+        this._healthCheckFn = config.healthCheckFn;
+    }
+    /**
+     * Get supported models
+     */
+    getModels() {
+        return [...this._models];
+    }
+    /**
+     * Get capabilities
+     */
+    getCapabilities() {
+        return [...this._capabilities];
+    }
+    /**
+     * Get rate limits
+     */
+    getRateLimits() {
+        return { ...this._rateLimits };
+    }
+    /**
+     * Check if model is supported
+     */
+    supportsModel(model) {
+        return this._models.some((m) => m.toLowerCase() === model.toLowerCase());
+    }
+    /**
+     * Get default model
+     */
+    getDefaultModel() {
+        return this._defaultModel;
+    }
+    /**
+     * Get max tokens for a model
+     */
+    getMaxTokens(model) {
+        const modelToCheck = model ?? this._defaultModel;
+        // Try exact match first
+        if (this._maxTokens[modelToCheck]) {
+            return this._maxTokens[modelToCheck];
+        }
+        // Try to find a prefix match
+        for (const [key, value] of Object.entries(this._maxTokens)) {
+            if (modelToCheck?.toLowerCase().startsWith(key.toLowerCase())) {
+                return value;
+            }
+        }
+        return this._maxTokens.default ?? 4096;
+    }
+    /**
+     * Invoke the adapter
+     */
+    async invoke(request) {
+        const start = Date.now();
+        try {
+            const response = await this._invokeFn(request);
+            return {
+                response,
+                retryable: false,
+                latencyMs: Date.now() - start,
+            };
+        }
+        catch (error) {
+            const errorAnalysis = this._errorParserFn(error);
+            const latencyMs = Date.now() - start;
+            return {
+                response: {
+                    content: "",
+                    error: errorAnalysis.message,
+                },
+                quotaSignal: errorAnalysis.quotaSignal,
+                retryable: errorAnalysis.rateLimited ||
+                    errorAnalysis.serverError ||
+                    errorAnalysis.timeout,
+                latencyMs,
+            };
+        }
+    }
+    /**
+     * Parse an error
+     */
+    parseError(error) {
+        return this._errorParserFn(error);
+    }
+    /**
+     * Health check
+     */
+    async healthCheck() {
+        if (this._healthCheckFn) {
+            return this._healthCheckFn();
+        }
+        // Default health check - just return healthy
+        return {
+            healthy: true,
+            timestamp: new Date().toISOString(),
+        };
+    }
+    /**
+     * Convert to adapter info for registry
+     */
+    toConfig() {
+        return {
+            id: this.id,
+            name: this.name,
+            models: this._models,
+            capabilities: this._capabilities,
+            rateLimits: this._rateLimits,
+            defaultModel: this._defaultModel,
+            maxTokens: this._maxTokens,
+        };
+    }
+}
+//# sourceMappingURL=builder.js.map

package/packages/provider-adapter-sdk/dist/src/errors.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Provider Adapter SDK - Errors
+ *
+ * Custom error classes for the adapter SDK.
+ */
+/**
+ * Base error for adapter SDK
+ */
+export declare class AdapterError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, details?: Record<string, unknown> | undefined);
+}
+/**
+ * Thrown when an adapter is not found in registry
+ */
+export declare class AdapterNotFoundError extends AdapterError {
+    constructor(adapterId: string);
+}
+/**
+ * Thrown when an adapter is already registered
+ */
+export declare class AdapterAlreadyRegisteredError extends AdapterError {
+    constructor(adapterId: string);
+}
+/**
+ * Thrown when adapter invocation fails
+ */
+export declare class AdapterInvocationError extends AdapterError {
+    readonly adapterId: string;
+    readonly retryable: boolean;
+    readonly originalError?: unknown;
+    constructor(message: string, adapterId: string, retryable: boolean, originalError?: unknown);
+}
+/**
+ * Thrown when a model is not supported
+ */
+export declare class ModelNotSupportedError extends AdapterError {
+    constructor(model: string, adapterId: string, supportedModels: string[]);
+}
+/**
+ * Thrown when adapter is not in expected state
+ */
+export declare class AdapterStateError extends AdapterError {
+    constructor(adapterId: string, expectedState: string, actualState: string);
+}
+/**
+ * Thrown when compatibility check fails
+ */
+export declare class CompatibilityError extends AdapterError {
+    constructor(adapterId: string, issues: string[], sdkVersion: string, runtimeVersion?: string);
+}
+/**
+ * Thrown when test fails
+ */
+export declare class TestFailureError extends AdapterError {
+    constructor(adapterId: string, testName: string, message: string, error?: unknown);
+}
+/**
+ * Thrown when builder validation fails
+ */
+export declare class BuilderValidationError extends AdapterError {
+    constructor(message: string, field: string);
+}
+/**
+ * Thrown when lifecycle hook fails
+ */
+export declare class LifecycleError extends AdapterError {
+    constructor(hook: string, adapterId: string, originalError: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/packages/provider-adapter-sdk/dist/src/errors.js

@@ -0,0 +1,111 @@
+/**
+ * Provider Adapter SDK - Errors
+ *
+ * Custom error classes for the adapter SDK.
+ */
+/**
+ * Base error for adapter SDK
+ */
+export class AdapterError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = "AdapterError";
+    }
+}
+/**
+ * Thrown when an adapter is not found in registry
+ */
+export class AdapterNotFoundError extends AdapterError {
+    constructor(adapterId) {
+        super(`Adapter '${adapterId}' not found in registry`, "ADAPTER_NOT_FOUND", {
+            adapterId,
+        });
+        this.name = "AdapterNotFoundError";
+    }
+}
+/**
+ * Thrown when an adapter is already registered
+ */
+export class AdapterAlreadyRegisteredError extends AdapterError {
+    constructor(adapterId) {
+        super(`Adapter '${adapterId}' is already registered`, "ADAPTER_ALREADY_REGISTERED", { adapterId });
+        this.name = "AdapterAlreadyRegisteredError";
+    }
+}
+/**
+ * Thrown when adapter invocation fails
+ */
+export class AdapterInvocationError extends AdapterError {
+    adapterId;
+    retryable;
+    originalError;
+    constructor(message, adapterId, retryable, originalError) {
+        super(message, "ADAPTER_INVOCATION_ERROR", {
+            adapterId,
+            retryable,
+        });
+        this.adapterId = adapterId;
+        this.retryable = retryable;
+        this.originalError = originalError;
+        this.name = "AdapterInvocationError";
+    }
+}
+/**
+ * Thrown when a model is not supported
+ */
+export class ModelNotSupportedError extends AdapterError {
+    constructor(model, adapterId, supportedModels) {
+        super(`Model '${model}' is not supported by adapter '${adapterId}'`, "MODEL_NOT_SUPPORTED", { model, adapterId, supportedModels });
+        this.name = "ModelNotSupportedError";
+    }
+}
+/**
+ * Thrown when adapter is not in expected state
+ */
+export class AdapterStateError extends AdapterError {
+    constructor(adapterId, expectedState, actualState) {
+        super(`Adapter '${adapterId}' is in state '${actualState}', expected '${expectedState}'`, "ADAPTER_STATE_ERROR", { adapterId, expectedState, actualState });
+        this.name = "AdapterStateError";
+    }
+}
+/**
+ * Thrown when compatibility check fails
+ */
+export class CompatibilityError extends AdapterError {
+    constructor(adapterId, issues, sdkVersion, runtimeVersion) {
+        super(`Adapter '${adapterId}' is not compatible: ${issues.join(", ")}`, "COMPATIBILITY_ERROR", { adapterId, issues, sdkVersion, runtimeVersion });
+        this.name = "CompatibilityError";
+    }
+}
+/**
+ * Thrown when test fails
+ */
+export class TestFailureError extends AdapterError {
+    constructor(adapterId, testName, message, error) {
+        super(`Test '${testName}' failed for adapter '${adapterId}': ${message}`, "TEST_FAILURE", { adapterId, testName, originalError: error });
+        this.name = "TestFailureError";
+    }
+}
+/**
+ * Thrown when builder validation fails
+ */
+export class BuilderValidationError extends AdapterError {
+    constructor(message, field) {
+        super(message, "BUILDER_VALIDATION_ERROR", { field });
+        this.name = "BuilderValidationError";
+    }
+}
+/**
+ * Thrown when lifecycle hook fails
+ */
+export class LifecycleError extends AdapterError {
+    constructor(hook, adapterId, originalError) {
+        super(`Lifecycle hook '${hook}' failed for adapter '${adapterId}'`, "LIFECYCLE_ERROR", { hook, adapterId, originalError });
+        this.name = "LifecycleError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/packages/provider-adapter-sdk/dist/src/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Provider Adapter SDK
+ *
+ * A comprehensive SDK for building, testing, and registering provider adapters.
+ */
+export { AdapterBuilder, BuiltAdapter } from "./builder.js";
+export { AdapterRegistry, type RegistryConfig } from "./registry.js";
+export { AdapterTester, assertTestResults, } from "./tester.js";
+export type { AdapterVersion, AdapterResult, ErrorAnalysis, QuotaSignal, RateLimitConfig, AdapterBuilderConfig, InvokeFunction, ErrorParserFunction, HealthCheckFunction, HealthCheckResult, AdapterInfo, AdapterLifecycle, AdapterState, CompatibilityResult, TestConfig, TestResult, TestReport, MockResponse, RegistryEvents, ProviderCapability, ProviderRequest, ProviderResponse, } from "./types.js";
+export { AdapterError, AdapterNotFoundError, AdapterAlreadyRegisteredError, AdapterInvocationError, ModelNotSupportedError, AdapterStateError, CompatibilityError, TestFailureError, BuilderValidationError, LifecycleError, } from "./errors.js";
+/**
+ * SDK version
+ */
+export { SDK_VERSION, SDK_VERSION as ADAPTER_SDK_VERSION } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/packages/provider-adapter-sdk/dist/src/index.js

@@ -0,0 +1,19 @@
+/**
+ * Provider Adapter SDK
+ *
+ * A comprehensive SDK for building, testing, and registering provider adapters.
+ */
+// ─── Builder ────────────────────────────────────────────────────────────────
+export { AdapterBuilder, BuiltAdapter } from "./builder.js";
+// ─── Registry ────────────────────────────────────────────────────────────────
+export { AdapterRegistry } from "./registry.js";
+// ─── Tester ─────────────────────────────────────────────────────────────────
+export { AdapterTester, assertTestResults, } from "./tester.js";
+// ─── Errors ─────────────────────────────────────────────────────────────────
+export { AdapterError, AdapterNotFoundError, AdapterAlreadyRegisteredError, AdapterInvocationError, ModelNotSupportedError, AdapterStateError, CompatibilityError, TestFailureError, BuilderValidationError, LifecycleError, } from "./errors.js";
+// ─── Constants ───────────────────────────────────────────────────────────────
+/**
+ * SDK version
+ */
+export { SDK_VERSION, SDK_VERSION as ADAPTER_SDK_VERSION } from "./types.js";
+//# sourceMappingURL=index.js.map