@agent-os-sdk/client 0.9.25 → 0.9.27

package/src/client/raw.ts

@@ -1,609 +0,0 @@
-/**
- * Agent OS SDK - Raw HTTP Client
- * 
- * Fully typed HTTP client using openapi-fetch with generated OpenAPI types.
- * All types are automatically inferred from the backend Swagger specification.
- */
-
-import createClient, { type Client } from "openapi-fetch";
-import type { components, paths } from "../generated/openapi.js";
-import { createErrorFromResponse } from "../errors/factory.js";
-import { AgentOsError, NetworkError, TimeoutError } from "../errors/index.js";
-import { httpRequestBuilder, sanitizeValidCorrelationId } from "./HttpRequestBuilder.js";
-import type { OperationContext } from "./OperationContext.js";
-import type { OperationContextProvider } from "./OperationContextProvider.js";
-import { mergeNetworkConfig, type NetworkConfig } from "./config.js";
-import { withRetry } from "./retry.js";
-import { withTimeout } from "./timeout.js";
-
-// Re-export types for external use
-export type { components, paths };
-
-export type ClientOptions = {
-    baseUrl: string;
-    headers?: Record<string, string>;
-    headerProvider?: () => Promise<Record<string, string>>;
-    /** Optional flow context provider (ALS/manual). */
-    contextProvider?: OperationContextProvider;
-    /** Network behavior (timeouts/retries). Defaults to DEFAULT_NETWORK_CONFIG. */
-    network?: Partial<NetworkConfig>;
-    /** Hooks for observability (OTEL, Sentry, etc.) */
-    hooks?: SDKHooks;
-};
-
-/**
- * SDK hooks for external observability tools.
- * These are called during the request lifecycle for instrumentation.
- */
-export interface SDKHooks {
-    /** Called before each request. Return modified request context or void. */
-    onRequest?: (context: HookRequestContext) => void | Promise<void>;
-    /** Called after each successful response */
-    onResponse?: (context: HookResponseContext) => void | Promise<void>;
-    /** Called on any error (network, timeout, HTTP error) */
-    onError?: (context: HookErrorContext) => void | Promise<void>;
-    /** Optional logger bridge used by SDK internal warnings. */
-    logger?: { warn?: (message: string) => void };
-}
-
-export interface HookRequestContext {
-    method: string;
-    url: string;
-    headers: Record<string, string>;
-    body?: unknown;
-    requestId?: string;
-}
-
-export interface HookResponseContext {
-    method: string;
-    url: string;
-    status: number;
-    durationMs: number;
-    requestId?: string;
-}
-
-export interface HookErrorContext {
-    method: string;
-    url: string;
-    error: Error;
-    durationMs: number;
-    requestId?: string;
-}
-
-/**
- * Standard API response wrapper.
- * This matches the pattern used by openapi-fetch.
- */
-export interface APIResponse<T> {
-    data?: T;
-    error?: {
-        code: string;
-        message: string;
-        details?: unknown;
-    };
-    response: Response;
-    /** Metadata for observability */
-    meta?: {
-        /** Request ID from x-request-id header */
-        requestId?: string;
-    };
-}
-
-/**
- * Typed API client using openapi-fetch.
- * All paths and responses are fully typed from OpenAPI spec.
- */
-export type TypedClient = Client<paths>;
-
-/**
- * Creates a typed HTTP client with openapi-fetch.
- * This provides full type inference for all API endpoints.
- */
-export function createTypedClient(options: ClientOptions): TypedClient {
-    return createClient<paths>({
-        baseUrl: options.baseUrl,
-        headers: options.headers,
-    });
-}
-
-/**
- * Legacy raw client interface (for backward compatibility).
- * Wraps openapi-fetch to provide the old interface while maintaining types.
- */
-export function createRawClient(options: ClientOptions) {
-    const { baseUrl, headers: defaultHeaders = {}, headerProvider, contextProvider } = options;
-    const networkConfig = mergeNetworkConfig(options.network);
-    const warn = (message: string): void => {
-        const hookWarn = options.hooks?.logger?.warn;
-        if (typeof hookWarn === "function") {
-            hookWarn(message);
-            return;
-        }
-        if (typeof console !== "undefined" && typeof console.warn === "function") {
-            console.warn(message);
-        }
-    };
-    // Sticky fallback context for clients that don't provide per-operation context.
-    const fallbackContext: OperationContext = Object.freeze({
-        correlationId: crypto.randomUUID(),
-    });
-    let warnedStickyFallbackContext = false;
-    let warnedInvalidContextCorrelation = false;
-    const resolveEffectiveContext = (optsContext?: OperationContext): OperationContext => {
-        const providerContext = contextProvider?.get();
-        const usingStickyFallback = !optsContext && !providerContext;
-        if (usingStickyFallback && !contextProvider && !warnedStickyFallbackContext) {
-            warnedStickyFallbackContext = true;
-            warn(
-                "[AgentOS SDK] Using sticky fallback correlation context per client instance. " +
-                "For long-lived server clients, configure contextProvider (ALS/manual) to scope correlation per request."
-            );
-        }
-
-        const effectiveContext = optsContext ?? providerContext ?? fallbackContext;
-        const correlationProvidedByCaller =
-            effectiveContext !== fallbackContext
-            && typeof effectiveContext?.correlationId === "string";
-
-        if (correlationProvidedByCaller) {
-            const validCorrelation = sanitizeValidCorrelationId(effectiveContext.correlationId);
-            if (!validCorrelation) {
-                if (!warnedInvalidContextCorrelation) {
-                    warnedInvalidContextCorrelation = true;
-                    warn(
-                        "[AgentOS SDK] Invalid correlationId in operation context ignored; generated fallback correlation id. " +
-                        "Provide a valid correlationId (8-128 chars: A-Za-z0-9._:-)."
-                    );
-                }
-                // Caller provided invalid flow id: use per-request fallback (not sticky fallback context).
-                return {
-                    ...effectiveContext,
-                    correlationId: crypto.randomUUID(),
-                };
-            }
-
-            if (validCorrelation !== effectiveContext.correlationId) {
-                return {
-                    ...effectiveContext,
-                    correlationId: validCorrelation,
-                };
-            }
-        }
-
-        return effectiveContext;
-    };
-    type ErrorPayload = { code?: string; message?: string; details?: unknown } & Record<string, unknown>;
-    type HttpAgentOsError = AgentOsError & {
-        response?: Response;
-        payload?: ErrorPayload;
-    };
-
-    async function request<T>(
-        method: string,
-        path: string,
-        opts?: {
-            params?: { path?: Record<string, string>; query?: Record<string, unknown> };
-            body?: unknown;
-            headers?: Record<string, string>;
-            signal?: AbortSignal;
-            /** Set to false to disable retry for this request */
-            retry?: boolean;
-            /** Override timeout for this request */
-            timeoutMs?: number;
-            /** Operation context for flow tracing */
-            context?: OperationContext;
-            /** Idempotency key for POST requests */
-            idempotencyKey?: string;
-            /** Require correlation ID (throws if missing) */
-            requireFlow?: boolean;
-        }
-    ): Promise<APIResponse<T>> {
-        // Replace path params
-        let url = path;
-        if (opts?.params?.path) {
-            for (const [key, value] of Object.entries(opts.params.path)) {
-                url = url.replace(`{${key}}`, encodeURIComponent(value));
-                // Also handle {id} pattern common in our API
-                url = url.replace(`{id}`, encodeURIComponent(value));
-            }
-        }
-
-        // Build query string
-        if (opts?.params?.query) {
-            const query = new URLSearchParams();
-            for (const [key, value] of Object.entries(opts.params.query)) {
-                if (value !== undefined && value !== null) {
-                    query.append(key, String(value));
-                }
-            }
-            const queryStr = query.toString();
-            if (queryStr) {
-                url += `?${queryStr}`;
-            }
-        }
-
-        const fullUrl = `${baseUrl}${url}`;
-
-        // Resolve dynamic headers (e.g. auth)
-        const dynamicHeaders = headerProvider ? await headerProvider() : {};
-
-        const headers: Record<string, string> = {
-            ...defaultHeaders,
-            ...dynamicHeaders,
-            ...opts?.headers,
-        };
-
-        if (opts?.body) {
-            headers["Content-Type"] = "application/json";
-        }
-
-        const effectiveContext = resolveEffectiveContext(opts?.context);
-
-        // Build standard headers via HttpRequestBuilder (single source of truth)
-        const builderHeaders = httpRequestBuilder.build({
-            context: effectiveContext,
-            idempotencyKey: opts?.idempotencyKey,
-            requireFlow: opts?.requireFlow,
-        });
-
-        // Merge builder headers (X-Request-Id, X-Correlation-Id, X-Idempotency-Key, User-Agent)
-        Object.assign(headers, builderHeaders);
-
-        // Use X-Request-Id from builder as client request ID
-        const clientRequestId = headers["X-Request-Id"];
-
-        // Call onRequest hook
-        const startTime = Date.now();
-        await options.hooks?.onRequest?.({
-            method,
-            url: fullUrl,
-            headers,
-            body: opts?.body,
-            requestId: clientRequestId,
-        });
-
-        // Execute the actual fetch
-        const doFetch = async (signal?: AbortSignal): Promise<Response> => {
-            return fetch(fullUrl, {
-                method,
-                headers,
-                body: opts?.body ? JSON.stringify(opts.body) : undefined,
-                signal,
-            });
-        };
-
-        let response: Response;
-        try {
-            const hasIdempotencyKey = Boolean(
-                opts?.idempotencyKey ||
-                headers["X-Idempotency-Key"] ||
-                headers["Idempotency-Key"]
-            );
-
-            const executeAttempt = async (signal?: AbortSignal): Promise<Response> => {
-                const attemptResponse = await withTimeout(async (timeoutSignal) => {
-                    try {
-                        return await doFetch(timeoutSignal);
-                    } catch (fetchError) {
-                        // Preserve AbortError semantics for caller-provided cancellation.
-                        if (fetchError instanceof Error && fetchError.name === "AbortError") {
-                            throw fetchError;
-                        }
-
-                        throw new NetworkError(
-                            fetchError instanceof Error ? fetchError.message : "Network request failed",
-                            fetchError instanceof Error ? fetchError : undefined
-                        );
-                    }
-                }, opts?.timeoutMs ?? networkConfig.timeoutMs, signal);
-
-                if (!attemptResponse.ok) {
-                    let errorBody: ErrorPayload | undefined;
-                    try {
-                        errorBody = await attemptResponse.json() as ErrorPayload;
-                    } catch {
-                        // Ignore JSON parse errors and fallback to status text.
-                    }
-
-                    const typedError = createErrorFromResponse(attemptResponse, errorBody, path) as HttpAgentOsError;
-                    typedError.response = attemptResponse;
-                    typedError.payload = errorBody;
-                    throw typedError;
-                }
-
-                return attemptResponse;
-            };
-
-            if (opts?.retry === false) {
-                response = await executeAttempt(opts?.signal);
-            } else {
-                response = await withRetry(
-                    (signal) => executeAttempt(signal),
-                    networkConfig.retry,
-                    { method, hasIdempotencyKey },
-                    opts?.signal
-                );
-            }
-        } catch (requestError) {
-            const durationMs = Date.now() - startTime;
-            const error = requestError instanceof Error ? requestError : new Error(String(requestError));
-            const typedError = requestError instanceof AgentOsError ? requestError as HttpAgentOsError : undefined;
-            const errorResponse = typedError?.response;
-            const requestId = errorResponse?.headers.get("x-request-id")
-                ?? typedError?.requestId
-                ?? clientRequestId;
-
-            // Call onError hook
-            await options.hooks?.onError?.({
-                method,
-                url: fullUrl,
-                error,
-                durationMs,
-                requestId,
-            });
-
-            if (typedError && errorResponse) {
-                return {
-                    error: {
-                        code: typedError.backendCode || typedError.code,
-                        message: typedError.message,
-                        details: typedError.details,
-                        // Include full payload for validation hints and backend-specific fields.
-                        ...typedError.payload,
-                    },
-                    response: errorResponse,
-                    meta: { requestId },
-                };
-            }
-
-            if (error instanceof TimeoutError) {
-                return {
-                    error: {
-                        code: error.code,
-                        message: error.message,
-                    },
-                    response: new Response(null, { status: 408, statusText: "Request Timeout" }),
-                    meta: { requestId },
-                };
-            }
-
-            // Network/abort/unexpected errors - return as standardized transport error.
-            return {
-                error: {
-                    code: "NETWORK_ERROR",
-                    message: error.message || "Network request failed"
-                },
-                response: new Response(null, { status: 503, statusText: "Network Error" }),
-                meta: { requestId },
-            };
-        }
-
-        const durationMs = Date.now() - startTime;
-
-        // Extract requestId for tracing (prefer server requestId if available)
-        const requestId = response.headers.get("x-request-id") ?? clientRequestId;
-
-        // Call onResponse hook
-        await options.hooks?.onResponse?.({
-            method,
-            url: fullUrl,
-            status: response.status,
-            durationMs,
-            requestId,
-        });
-
-        // Handle no-content responses
-        if (response.status === 204) {
-            return { data: undefined as T, response, meta: { requestId } };
-        }
-
-        try {
-            const data = await response.json();
-            return { data: data as T, response, meta: { requestId } };
-        } catch {
-            return { data: undefined as T, response, meta: { requestId } };
-        }
-    }
-
-    return {
-        GET: <T>(path: string, opts?: Parameters<typeof request>[2]) =>
-            request<T>("GET", path, opts),
-        POST: <T>(path: string, opts?: Parameters<typeof request>[2]) =>
-            request<T>("POST", path, opts),
-        PUT: <T>(path: string, opts?: Parameters<typeof request>[2]) =>
-            request<T>("PUT", path, opts),
-        PATCH: <T>(path: string, opts?: Parameters<typeof request>[2]) =>
-            request<T>("PATCH", path, opts),
-        DELETE: <T>(path: string, opts?: Parameters<typeof request>[2]) =>
-            request<T>("DELETE", path, opts),
-
-        /**
-         * Stream GET request - returns raw Response for SSE consumption.
-         * Headers are resolved asynchronously (includes Auth + Workspace).
-         */
-        streamGet: async (
-            path: string,
-            opts?: {
-                params?: { path?: Record<string, string>; query?: Record<string, unknown> };
-                headers?: Record<string, string>;
-                context?: OperationContext;
-                requireFlow?: boolean;
-                signal?: AbortSignal;
-            }
-        ): Promise<Response> => {
-            let url = path;
-            if (opts?.params?.path) {
-                for (const [key, value] of Object.entries(opts.params.path)) {
-                    url = url.replace(`{${key}}`, encodeURIComponent(value));
-                }
-            }
-            if (opts?.params?.query) {
-                const query = new URLSearchParams();
-                for (const [key, value] of Object.entries(opts.params.query)) {
-                    if (value !== undefined && value !== null) {
-                        query.append(key, String(value));
-                    }
-                }
-                const queryStr = query.toString();
-                if (queryStr) url += `?${queryStr}`;
-            }
-            const fullUrl = `${baseUrl}${url}`;
-            const dynamicHeaders = headerProvider ? await headerProvider() : {};
-            const effectiveContext = resolveEffectiveContext(opts?.context);
-            const builderHeaders = httpRequestBuilder.build({
-                context: effectiveContext,
-                requireFlow: opts?.requireFlow,
-            });
-            const headers: Record<string, string> = {
-                ...defaultHeaders,
-                ...dynamicHeaders,
-                ...builderHeaders,
-                Accept: "text/event-stream",
-                ...opts?.headers,
-            };
-            return fetch(fullUrl, { method: "GET", headers, signal: opts?.signal });
-        },
-
-        /**
-         * Stream POST request - returns raw Response for SSE consumption.
-         * Headers are resolved asynchronously (includes Auth + Workspace).
-         */
-        streamPost: async (
-            path: string,
-            opts?: {
-                params?: { path?: Record<string, string> };
-                body?: unknown;
-                headers?: Record<string, string>;
-                signal?: AbortSignal;
-                context?: OperationContext;
-                idempotencyKey?: string;
-                requireFlow?: boolean;
-            }
-        ): Promise<Response> => {
-            let url = path;
-            if (opts?.params?.path) {
-                for (const [key, value] of Object.entries(opts.params.path)) {
-                    url = url.replace(`{${key}}`, encodeURIComponent(value));
-                }
-            }
-            const fullUrl = `${baseUrl}${url}`;
-            const dynamicHeaders = headerProvider ? await headerProvider() : {};
-            const effectiveContext = resolveEffectiveContext(opts?.context);
-            const builderHeaders = httpRequestBuilder.build({
-                context: effectiveContext,
-                idempotencyKey: opts?.idempotencyKey,
-                requireFlow: opts?.requireFlow,
-            });
-            const headers: Record<string, string> = {
-                ...defaultHeaders,
-                ...dynamicHeaders,
-                ...builderHeaders,
-                "Content-Type": "application/json",
-                Accept: "text/event-stream",
-                ...opts?.headers,
-            };
-            return fetch(fullUrl, {
-                method: "POST",
-                headers,
-                body: opts?.body ? JSON.stringify(opts.body) : undefined,
-                signal: opts?.signal,
-            });
-        },
-
-        /** Base URL for constructing full URLs when needed */
-        baseUrl,
-    };
-}
-
-export type RawClient = ReturnType<typeof createRawClient>;
-
-// ============================================================================
-// Convenience type exports from OpenAPI schemas
-// ============================================================================
-
-// Agent types
-export type Agent = components["schemas"]["AgentExportAgent"];
-export type CreateAgentRequest = components["schemas"]["CreateAgentRequest"];
-export type UpdateAgentRequest = components["schemas"]["UpdateAgentRequest"];
-export type AgentBundle = components["schemas"]["AgentExportBundle"];
-export type AgentBundleItem = components["schemas"]["AgentBundleItem"];
-
-// Run types
-export type RunResponse = components["schemas"]["RunResponse"];
-export type RunDetailResponse = components["schemas"]["RunDetailResponse"];
-export type CreateRunRequest = components["schemas"]["CreateRunRequest"];
-export type WaitRunRequest = components["schemas"]["WaitRunRequest"];
-export type WaitRunResponse = components["schemas"]["WaitRunResponse"];
-export type BatchRunRequest = components["schemas"]["BatchRunRequest"];
-export type BatchRunResponse = components["schemas"]["BatchRunResponse"];
-export type ReplayRequest = components["schemas"]["ReplayRequest"];
-export type RunReplayRequest = components["schemas"]["RunReplayRequest"];
-export type RunReplayResponse = components["schemas"]["RunReplayResponse"];
-export type CancelRequest = components["schemas"]["CancelRequest"];
-export type CancelRunResponse = components["schemas"]["CancelRunResponse"];
-
-// Thread types
-export type ThreadRequest = components["schemas"]["ThreadRequest"];
-export type ThreadSearchRequest = components["schemas"]["ThreadSearchRequest"];
-export type ThreadCopyRequest = components["schemas"]["ThreadCopyRequest"];
-export type ThreadPruneRequest = components["schemas"]["ThreadPruneRequest"];
-export type AddMessageRequest = components["schemas"]["AddMessageRequest"];
-
-// Checkpoint types
-export type CheckpointDetail = components["schemas"]["CheckpointDetail"];
-export type CheckpointNode = components["schemas"]["CheckpointNode"];
-export type CheckpointListResponse = components["schemas"]["CheckpointListResponse"];
-export type CheckpointIndexResponse = components["schemas"]["CheckpointIndexResponse"];
-export type CreateCheckpointRequest = components["schemas"]["CreateCheckpointRequest"];
-
-// Credential types
-export type CreateCredentialRequest = components["schemas"]["CreateCredentialRequest"];
-export type UpdateCredentialRequest = components["schemas"]["UpdateCredentialRequest"];
-
-// Evaluation types
-export type CreateDatasetRequest = components["schemas"]["CreateDatasetRequest"];
-export type CreateExperimentRequest = components["schemas"]["CreateExperimentRequest"];
-export type ExampleData = components["schemas"]["ExampleData"];
-export type AddExamplesRequest = components["schemas"]["AddExamplesRequest"];
-
-// Vector Store types
-export type VectorStoreResponse = components["schemas"]["VectorStoreResponse"];
-export type VectorQueryRequest = components["schemas"]["VectorQueryRequest"];
-export type VectorQueryResponse = components["schemas"]["VectorQueryResponse"];
-export type VectorSearchResult = components["schemas"]["VectorSearchResult"];
-export type VectorStoreFileResponse = components["schemas"]["VectorStoreFileResponse"];
-
-// Cron types
-export type CreateCronJobRequest = components["schemas"]["CreateCronJobRequest"];
-export type UpdateCronJobRequest = components["schemas"]["UpdateCronJobRequest"];
-
-// Member types
-export type InviteMemberRequest = components["schemas"]["InviteMemberRequest"];
-export type UpdateMemberRequest = components["schemas"]["UpdateMemberRequest"];
-
-// Tenant/Workspace types
-export type UpdateTenantRequest = components["schemas"]["UpdateTenantRequest"];
-export type UpdateWorkspaceRequest = components["schemas"]["UpdateWorkspaceRequest"];
-
-// Prompt types
-export type CreatePromptRequest = components["schemas"]["CreatePromptRequest"];
-export type CreatePromptVersionRequest = components["schemas"]["CreatePromptVersionRequest"];
-
-// File types
-export type CreatePresignedUploadRequest = components["schemas"]["CreatePresignedUploadRequest"];
-export type PresignedUploadResponse = components["schemas"]["PresignedUploadResponse"];
-export type ConfirmUploadRequest = components["schemas"]["ConfirmUploadRequest"];
-
-// Trace types
-export type SpanData = components["schemas"]["SpanData"];
-export type BatchIngestRequest = components["schemas"]["BatchIngestRequest"];
-export type AddFeedbackRequest = components["schemas"]["AddFeedbackRequest"];
-
-// Trigger types
-export type UpdateTriggerRequest = components["schemas"]["UpdateTriggerRequest"];
-
-// Store types
-export type StoreValueRequest = components["schemas"]["StoreValueRequest"];
-
-// Problem details (errors)
-export type ProblemDetails = components["schemas"]["ProblemDetails"];