@agent-os-sdk/client 0.1.0

package/src/modules/vectorStores.ts

@@ -0,0 +1,160 @@
+/**
+ * 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;
+    workspace_id: string;
+    embedding_provider: string;
+    embedding_model: string;
+    dimension: number;
+    credential_binding_alias?: 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;
+}
+
+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>> {
+        return this.client.GET<VectorStoreListResponse>("/v1/api/vector-stores", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a vector store by ID.
+     */
+    async get(storeId: string): Promise<APIResponse<VectorStore>> {
+        return this.client.GET<VectorStore>("/v1/api/vector-stores/{id}", {
+            params: { path: { id: storeId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create a new vector store.
+     */
+    async create(body: {
+        name: string;
+        embedding_provider?: string;
+        embedding_model?: string;
+        dimension?: number;
+        credential_binding_alias?: string;
+    }): Promise<APIResponse<VectorStore>> {
+        return this.client.POST<VectorStore>("/v1/api/vector-stores", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a vector store.
+     */
+    async delete(storeId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/vector-stores/{id}", {
+            params: { path: { id: 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<VectorQueryResult>("/v1/api/vector-stores/{id}/query", {
+            params: { path: { id: storeId } },
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    // ======================== Files ========================
+
+    /**
+     * List files in a vector store.
+     */
+    async listFiles(storeId: string, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<VectorStoreFilesResponse>> {
+        return this.client.GET<VectorStoreFilesResponse>("/v1/api/vector-stores/{id}/files", {
+            params: { path: { id: storeId }, query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Attach a file to a vector store.
+     */
+    async attachFile(storeId: string, fileId: string): Promise<APIResponse<VectorStoreFile>> {
+        return this.client.POST<VectorStoreFile>("/v1/api/vector-stores/{id}/files", {
+            params: { path: { id: storeId } },
+            body: { file_id: fileId },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * 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/{id}/files/{fileId}", {
+            params: { path: { id: storeId, fileId } },
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/workspaces.ts

@@ -0,0 +1,89 @@
+/**
+ * Workspaces Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+type UpdateWorkspaceRequest = components["schemas"]["UpdateWorkspaceRequest"];
+
+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(),
+        });
+    }
+}

package/src/sse/client.ts

@@ -0,0 +1,100 @@
+/**
+ * Agent OS SDK - SSE Client
+ * 
+ * Typed Server-Sent Events client for streaming endpoints.
+ */
+
+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;
+};
+
+/**
+ * Creates a typed SSE stream from a URL.
+ */
+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,
+    });
+
+    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 = "";
+
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() ?? "";
+
+            let currentEvent: Partial<SSEEvent<T>> = { event: "message" };
+
+            for (const line of lines) {
+                if (line.startsWith("event:")) {
+                    currentEvent.event = line.slice(6).trim();
+                } else if (line.startsWith("data:")) {
+                    const dataStr = line.slice(5).trim();
+                    try {
+                        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);
+                } else if (line === "" && currentEvent.data !== undefined) {
+                    yield currentEvent as SSEEvent<T>;
+                    currentEvent = { event: "message" };
+                }
+            }
+        }
+    } finally {
+        reader.releaseLock();
+    }
+}
+
+/**
+ * SSE Event types for Run streaming
+ */
+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 };