@agent-os-sdk/client 0.9.25 → 0.9.27

package/src/modules/vectorStores.ts

@@ -1,257 +0,0 @@
-/**
- * Vector Stores Module - Fully Typed
- */
-
-import type { RawClient, APIResponse, components } from "../client/raw.js";
-
-type VectorStoreResponse = components["schemas"]["VectorStoreResponse"];
-type VectorQueryResponse = components["schemas"]["VectorQueryResponse"];
-type VectorStoreFileResponse = components["schemas"]["VectorStoreFileResponse"];
-
-export interface VectorStore {
-    id: string;
-    name: string;
-    embedding_provider: string;
-    embedding_model: string;
-    dimension: number;
-    credential_binding_key?: string;
-    file_count: number;
-    created_at: string;
-}
-
-export interface VectorStoreListResponse {
-    items: VectorStore[];
-    total: number;
-}
-
-export interface VectorSearchResult {
-    id: string;
-    chunk_index: number;
-    content_text: string;
-    score: number;
-    file_id?: string;
-}
-
-export interface VectorQueryResult {
-    query: string;
-    results: VectorSearchResult[];
-    total_results: number;
-}
-
-export interface VectorStoreFile {
-    id: string;
-    file_id: string;
-    filename: string;
-    status: "pending" | "processing" | "completed" | "failed";
-    created_at: string;
-}
-
-export interface VectorStoreFilesResponse {
-    items: VectorStoreFile[];
-    total: number;
-}
-
-type VectorStoreLike = VectorStoreResponse & {
-    embeddingProvider?: string;
-    embeddingModel?: string;
-    credentialBindingKey?: string;
-    fileCount?: number;
-    createdAt?: string;
-};
-
-type VectorStoreFileLike = VectorStoreFileResponse & {
-    fileId?: string;
-    createdAt?: string;
-};
-
-function toVectorStore(item: VectorStoreLike): VectorStore {
-    return {
-        id: item.id ?? "",
-        name: item.name ?? "",
-        embedding_provider: item.embedding_provider ?? item.embeddingProvider ?? "",
-        embedding_model: item.embedding_model ?? item.embeddingModel ?? "",
-        dimension: item.dimension ?? 0,
-        credential_binding_key: item.credential_binding_key ?? item.credentialBindingKey ?? undefined,
-        file_count: item.file_count ?? item.fileCount ?? 0,
-        created_at: item.created_at ?? item.createdAt ?? "",
-    };
-}
-
-function toVectorStoreFile(item: VectorStoreFileLike): VectorStoreFile {
-    return {
-        id: item.id ?? "",
-        file_id: item.file_id ?? item.fileId ?? "",
-        filename: item.filename ?? "",
-        status: (item.status ?? "pending") as VectorStoreFile["status"],
-        created_at: item.created_at ?? item.createdAt ?? "",
-    };
-}
-
-export class VectorStoresModule {
-    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
-
-    /**
-     * List all vector stores.
-     */
-    async list(params?: {
-        workspace_id?: string;
-        limit?: number;
-        offset?: number;
-    }): Promise<APIResponse<VectorStoreListResponse>> {
-        const response = await this.client.GET<VectorStoreResponse[]>("/v1/api/vector-stores", {
-            params: { query: params },
-            headers: this.headers(),
-        });
-
-        const items = Array.isArray(response.data)
-            ? response.data.map((item) => toVectorStore(item))
-            : [];
-
-        return {
-            ...response,
-            data: {
-                items,
-                total: items.length,
-            },
-        };
-    }
-
-    /**
-     * Get a vector store by ID.
-     */
-    async get(storeId: string): Promise<APIResponse<VectorStore>> {
-        const response = await this.client.GET<VectorStoreResponse>("/v1/api/vector-stores/{vectorStoreId}", {
-            params: { path: { vectorStoreId: storeId } },
-            headers: this.headers(),
-        });
-
-        if (!response.data) {
-            return response as APIResponse<VectorStore>;
-        }
-
-        return {
-            ...response,
-            data: toVectorStore(response.data),
-        };
-    }
-
-    /**
-     * Create a new vector store.
-     */
-    async create(body: {
-        name: string;
-        embedding_provider?: string;
-        embedding_model?: string;
-        dimension?: number;
-        credential_binding_key?: string;
-    }): Promise<APIResponse<VectorStore>> {
-        const response = await this.client.POST<VectorStoreResponse>("/v1/api/vector-stores", {
-            body,
-            headers: this.headers(),
-        });
-
-        if (!response.data) {
-            return response as APIResponse<VectorStore>;
-        }
-
-        return {
-            ...response,
-            data: toVectorStore(response.data),
-        };
-    }
-
-    /**
-     * Delete a vector store.
-     */
-    async delete(storeId: string): Promise<APIResponse<void>> {
-        return this.client.DELETE<void>("/v1/api/vector-stores/{vectorStoreId}", {
-            params: { path: { vectorStoreId: storeId } },
-            headers: this.headers(),
-        });
-    }
-
-    // ======================== Query ========================
-
-    /**
-     * Query a vector store for similar content.
-     */
-    async query(storeId: string, body: {
-        query: string;
-        top_k?: number;
-        min_score?: number;
-    }): Promise<APIResponse<VectorQueryResult>> {
-        return this.client.POST<VectorQueryResponse>("/v1/api/vector-stores/{vectorStoreId}/query", {
-            params: { path: { vectorStoreId: storeId } },
-            body,
-            headers: this.headers(),
-        }) as Promise<APIResponse<VectorQueryResult>>;
-    }
-
-    // ======================== Files ========================
-
-    /**
-     * List files in a vector store.
-     */
-    async listFiles(storeId: string, params?: {
-        skip?: number;
-        take?: number;
-    }): Promise<APIResponse<VectorStoreFilesResponse>> {
-        const response = await this.client.GET<VectorStoreFileResponse[]>("/v1/api/vector-stores/{vectorStoreId}/files", {
-            params: { path: { vectorStoreId: storeId }, query: params },
-            headers: this.headers(),
-        });
-
-        const items = Array.isArray(response.data)
-            ? response.data.map((item) => toVectorStoreFile(item))
-            : [];
-
-        return {
-            ...response,
-            data: {
-                items,
-                total: items.length,
-            },
-        };
-    }
-
-    /**
-     * Attach a file to a vector store.
-     */
-    async attachFile(storeId: string, fileId: string): Promise<APIResponse<VectorStoreFile>> {
-        const response = await this.client.POST<VectorStoreFileResponse>("/v1/api/vector-stores/{vectorStoreId}/files", {
-            params: { path: { vectorStoreId: storeId } },
-            body: { file_id: fileId },
-            headers: this.headers(),
-        });
-
-        if (!response.data) {
-            return response as APIResponse<VectorStoreFile>;
-        }
-
-        return {
-            ...response,
-            data: toVectorStoreFile(response.data),
-        };
-    }
-
-    /**
-     * Remove a file from a vector store.
-     */
-    async removeFile(storeId: string, fileId: string): Promise<APIResponse<void>> {
-        return this.client.DELETE<void>("/v1/api/vector-stores/{vectorStoreId}/files/{fileId}", {
-            params: { path: { vectorStoreId: storeId, fileId } },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Bind a vector store to an agent.
-     */
-    async bindAgent(storeId: string, agentId: string): Promise<APIResponse<void>> {
-        return this.client.POST<void>("/v1/api/vector-stores/{vectorStoreId}/bind-agent", {
-            params: { path: { vectorStoreId: storeId } },
-            body: { agent_id: agentId },
-            headers: this.headers(),
-        });
-    }
-}

package/src/modules/workspaces.ts

@@ -1,216 +0,0 @@
-/**
- * Workspaces Module - Fully Typed
- */
-
-import type { RawClient, APIResponse, components } from "../client/raw.js";
-import { parseSSE } from "../sse/client.js";
-
-type UpdateWorkspaceRequest = components["schemas"]["UpdateWorkspaceRequest"];
-
-// ─── Workspace Event Types ─────────────────────────────────────
-
-/** Event emitted by workspace-level SSE stream. */
-export interface WorkspaceEvent {
-    type: string;
-    workspace_id: string;
-    run_id?: string;
-    agent_id?: string;
-    old_status?: string;
-    new_status?: string;
-    ts: number;
-}
-
-/** Options for followEvents(). */
-export interface WorkspaceFollowOptions {
-    /** AbortSignal to kill the SSE connection. Required for cleanup. */
-    signal?: AbortSignal;
-}
-
-export interface Workspace {
-    id: string;
-    tenant_id: string;
-    name: string;
-    is_default: boolean;
-    settings?: Record<string, unknown>;
-    created_at: string;
-    updated_at: string;
-}
-
-export interface WorkspaceListResponse {
-    items: Workspace[];
-    total: number;
-}
-
-export class WorkspacesModule {
-    constructor(
-        private client: RawClient,
-        private getTenantId: () => string,
-        private headers: () => Record<string, string>
-    ) { }
-
-    /**
-     * List all workspaces.
-     */
-    async list(params?: {
-        limit?: number;
-        offset?: number;
-    }): Promise<APIResponse<WorkspaceListResponse>> {
-        return this.client.GET<WorkspaceListResponse>("/v1/api/workspaces", {
-            params: { query: params },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Get a workspace by ID.
-     */
-    async get(workspaceId: string): Promise<APIResponse<Workspace>> {
-        return this.client.GET<Workspace>("/v1/api/workspaces/{id}", {
-            params: { path: { id: workspaceId } },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Create a new workspace.
-     */
-    async create(body: {
-        name: string;
-        is_default?: boolean;
-    }): Promise<APIResponse<Workspace>> {
-        return this.client.POST<Workspace>("/v1/api/workspaces", {
-            body,
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Update a workspace.
-     */
-    async update(workspaceId: string, body: {
-        name?: string;
-    }): Promise<APIResponse<Workspace>> {
-        return this.client.PUT<Workspace>("/v1/api/workspaces/{id}", {
-            params: { path: { id: workspaceId } },
-            body,
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Delete a workspace.
-     */
-    async delete(workspaceId: string): Promise<APIResponse<void>> {
-        return this.client.DELETE<void>("/v1/api/workspaces/{id}", {
-            params: { path: { id: workspaceId } },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Get workspace quotas.
-     */
-    async getQuotas(workspaceId: string): Promise<APIResponse<WorkspaceQuotaResponse>> {
-        return this.client.GET<WorkspaceQuotaResponse>("/v1/api/workspaces/{workspaceId}/quotas", {
-            params: { path: { workspaceId } },
-            headers: this.headers(),
-        });
-    }
-
-    /**
-     * Get workspace usage.
-     */
-    async getUsage(workspaceId: string, params?: { from?: string; to?: string }): Promise<APIResponse<WorkspaceUsageResponse>> {
-        return this.client.GET<WorkspaceUsageResponse>("/v1/api/workspaces/{workspaceId}/usage", {
-            params: { path: { workspaceId }, query: params },
-            headers: this.headers(),
-        });
-    }
-
-    // ======================== FOLLOW (Workspace SSE) ========================
-
-    /**
-     * Stream workspace events via SSE.
-     * Workspace identity flows via X-Workspace-Id header (same as all SDK methods).
-     *
-     * @param options - AbortSignal for cleanup (MUST be used to avoid leaking connections)
-     *
-     * @example
-     * ```ts
-     * const controller = new AbortController();
-     * for await (const event of client.workspaces.followEvents({ signal: controller.signal })) {
-     *   if (event.type === 'run_status_changed') {
-     *     console.log(`Run ${event.run_id} → ${event.new_status}`);
-     *   }
-     * }
-     * // On cleanup:
-     * controller.abort();
-     * ```
-     */
-    async *followEvents(options?: WorkspaceFollowOptions): AsyncGenerator<WorkspaceEvent, void, unknown> {
-        // Workspace identity flows via X-Workspace-Id header (set by this.headers()),
-        // consistent with all other SDK endpoints. No path param needed.
-        const response = await this.client.streamGet(
-            "/v1/api/workspaces/events/stream",
-            {
-                headers: this.headers(),
-                signal: options?.signal,
-            }
-        );
-
-        try {
-            for await (const rawEvent of parseSSE<WorkspaceEvent>(response)) {
-                if (rawEvent.data != null) {
-                    yield rawEvent.data;
-                }
-            }
-        } catch (err) {
-            // Abort is normal cleanup — not an error worth surfacing.
-            // Check both signal state and error name (covers proxy/wrapper edge cases).
-            if (options?.signal?.aborted) return;
-            if (err instanceof Error && err.name === "AbortError") return;
-            throw err;
-        }
-    }
-}
-
-export interface WorkspaceQuotaResponse {
-    workspace_id: string;
-    quotas: {
-        runs_per_month: Quota;
-        tokens_per_month: Quota;
-        agents_max: Quota;
-        storage_mb: Quota;
-    };
-    reset_at: string;
-    source: string;
-}
-
-export interface Quota {
-    limit: number;
-    used: number;
-    remaining: number;
-}
-
-export interface WorkspaceUsageResponse {
-    workspace_id: string;
-    period: { from: string; to: string };
-    usage: {
-        total_runs: number;
-        completed_runs: number;
-        failed_runs: number;
-        total_tokens: number;
-        input_tokens: number;
-        output_tokens: number;
-        total_duration_ms: number;
-        estimated_count: number;
-    };
-    daily_breakdown: Array<{
-        date: string;
-        runs: number;
-        tokens_in: number;
-        tokens_out: number;
-        duration_ms: number;
-    }>;
-    source: string;
-}

package/src/sse/client.ts

@@ -1,179 +0,0 @@
-/**
- * Agent OS SDK - SSE Client
- * 
- * Typed Server-Sent Events client for streaming endpoints.
- * 
- * This module provides utilities for parsing SSE responses.
- * The actual HTTP request should be made via rawClient.streamGet/streamPost.
- */
-
-export type SSEEvent<T = unknown> = {
-    id?: string;
-    event: string;
-    data: T;
-    retry?: number;
-};
-
-export type SSEOptions = {
-    headers?: Record<string, string>;
-    onOpen?: () => void;
-    onError?: (error: Error) => void;
-    signal?: AbortSignal;
-};
-
-/**
- * Parse SSE events from a Response object.
- * Use this with rawClient.streamGet() or rawClient.streamPost().
- * 
- * @example
- * ```ts
- * const response = await client.streamGet("/v1/api/runs/{runId}/events/stream", {
- *   params: { path: { runId }, query: { attemptId, afterSeq: 0 } }
- * });
- * for await (const event of parseSSE<RunStreamEvent>(response)) {
- *   console.log(event);
- * }
- * ```
- */
-export async function* parseSSE<T>(
-    response: Response,
-    options?: { onOpen?: () => void }
-): AsyncGenerator<SSEEvent<T>> {
-    if (!response.ok) {
-        throw new Error(`SSE connection failed: ${response.status}`);
-    }
-
-    if (!response.body) {
-        throw new Error("No response body");
-    }
-
-    options?.onOpen?.();
-
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-
-    let buffer = "";
-    // State must be maintained across chunks
-    let currentEvent: Partial<SSEEvent<T>> = { event: "message" };
-
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-
-            // Keep the last partial line in the buffer
-            buffer = lines.pop() ?? "";
-
-            for (const line of lines) {
-                const trimmed = line.trim();
-
-                if (trimmed === "") {
-                    // Empty line triggers event dispatch if we have data
-                    if (currentEvent.data !== undefined) {
-                        yield currentEvent as SSEEvent<T>;
-                    }
-                    // Reset for next event
-                    currentEvent = { event: "message" };
-                    continue;
-                }
-
-                if (line.startsWith("event:")) {
-                    currentEvent.event = line.slice(6).trim();
-                } else if (line.startsWith("data:")) {
-                    const dataStr = line.slice(5).trim();
-                    try {
-                        // Accumulate data if meaningful (though standard SSE usually has one data line per event, 
-                        // multiline data is possible but rare in this specific protocol. 
-                        // For simplicity and matching current backend, we overwrite or concatenation check could be stricter).
-                        // Given strict JSON protocol, we assume valid info per data line or single data line.
-                        currentEvent.data = JSON.parse(dataStr) as T;
-                    } catch {
-                        currentEvent.data = dataStr as T;
-                    }
-                } else if (line.startsWith("id:")) {
-                    currentEvent.id = line.slice(3).trim();
-                } else if (line.startsWith("retry:")) {
-                    currentEvent.retry = parseInt(line.slice(6).trim(), 10);
-                }
-            }
-        }
-    } finally {
-        reader.releaseLock();
-    }
-}
-
-/**
- * Legacy streamSSE function - DEPRECATED.
- * Use rawClient.streamGet() + parseSSE() instead.
- * 
- * Kept for backward compatibility during migration.
- * 
- * @deprecated Use rawClient.streamGet() + parseSSE() instead
- */
-export async function* streamSSE<T>(
-    url: string,
-    options: SSEOptions = {}
-): AsyncGenerator<SSEEvent<T>> {
-    const response = await fetch(url, {
-        method: "GET",
-        headers: {
-            Accept: "text/event-stream",
-            ...options.headers,
-        },
-        signal: options.signal,
-    });
-
-    yield* parseSSE<T>(response, { onOpen: options.onOpen });
-}
-
-/**
- * Run event from the execution ledger (Wave 2.3).
- * This is the actual payload sent within SSE `run_event` messages.
- */
-export interface RunEventDto {
-    id: string;
-    seq: number;
-    type: string;
-    timestamp: string;
-    attempt_id: string;
-    payload: Record<string, unknown> | null;
-    truncated?: boolean;
-}
-
-/**
- * SSE Event types for Run streaming (V1.2 Cinema Mode).
- * 
- * The server sends these event types:
- * - `connected`: Initial connection acknowledgment
- * - `run_event`: Individual run events from the ledger (with seq for resume)
- * - `heartbeat`: Keepalive every 15s
- * - `close`: Run reached terminal state (completed/failed/canceled)
- * - `error`: Stream error occurred
- * 
- * Each event has an `id` field containing the seq number for Last-Event-ID resume support.
- */
-export type RunSSEEvent =
-    | { event: "connected"; data: { run_id: string; start_seq: number } }
-    | { event: "run_event"; data: RunEventDto }
-    | { event: "heartbeat"; data: { timestamp: string } }
-    | { event: "close"; data: { final_status: string; final_seq: number } }
-    | { event: "error"; data: { code?: string; message: string } };
-
-/**
- * @deprecated Use RunSSEEvent for typed SSE events, or RunEventDto for event payloads.
- * Kept for backward compatibility.
- */
-export type RunStreamEvent =
-    | { type: "run_started"; run_id: string; status: string }
-    | { type: "node_started"; node_name: string; timestamp: string }
-    | { type: "node_completed"; node_name: string; output: unknown }
-    | { type: "tool_call"; tool_name: string; args: unknown }
-    | { type: "tool_result"; tool_name: string; result: unknown }
-    | { type: "checkpoint"; checkpoint_id: string; step_name: string }
-    | { type: "waiting_for_human"; prompt: string }
-    | { type: "run_completed"; output: unknown }
-    | { type: "run_failed"; error: unknown }
-    | { type: "heartbeat"; timestamp: string };