@agent-os-sdk/client 0.1.0

package/src/modules/files.ts

@@ -0,0 +1,112 @@
+/**
+ * Files Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+type CreatePresignedUploadRequest = components["schemas"]["CreatePresignedUploadRequest"];
+type PresignedUploadResponse = components["schemas"]["PresignedUploadResponse"];
+type ConfirmUploadRequest = components["schemas"]["ConfirmUploadRequest"];
+
+export interface StoredFile {
+    id: string;
+    filename: string;
+    content_type: string;
+    size_bytes: number;
+    sha256: string;
+    storage_uri: string;
+    workspace_id: string;
+    uploaded_by?: string;
+    status: "pending" | "confirmed" | "deleted";
+    created_at: string;
+}
+
+export interface FileListResponse {
+    items: StoredFile[];
+    total: number;
+}
+
+export interface PresignedUpload {
+    file_id: string;
+    upload_url: string;
+    expires_at: string;
+}
+
+export interface PresignedDownload {
+    download_url: string;
+    expires_at: string;
+}
+
+export class FilesModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * List all files.
+     */
+    async list(params?: {
+        workspace_id?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<FileListResponse>> {
+        return this.client.GET<FileListResponse>("/v1/api/files", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a file by ID.
+     */
+    async get(fileId: string): Promise<APIResponse<StoredFile>> {
+        return this.client.GET<StoredFile>("/v1/api/files/{id}", {
+            params: { path: { id: fileId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create a presigned upload URL.
+     */
+    async createUpload(body: {
+        filename: string;
+        content_type: string;
+        size_bytes?: number;
+        expected_sha256?: string;
+    }): Promise<APIResponse<PresignedUpload>> {
+        return this.client.POST<PresignedUpload>("/v1/api/files/upload", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Confirm an upload.
+     */
+    async confirmUpload(fileId: string, sha256: string): Promise<APIResponse<StoredFile>> {
+        return this.client.POST<StoredFile>("/v1/api/files/{id}/confirm", {
+            params: { path: { id: fileId } },
+            body: { sha256 },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a presigned download URL.
+     */
+    async getDownloadUrl(fileId: string): Promise<APIResponse<PresignedDownload>> {
+        return this.client.GET<PresignedDownload>("/v1/api/files/{id}/download", {
+            params: { path: { id: fileId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a file.
+     */
+    async delete(fileId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/files/{id}", {
+            params: { path: { id: fileId } },
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/graphs.ts

@@ -0,0 +1,50 @@
+/**
+ * Graphs Module - Validation and Introspection
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+export interface GraphValidationResult {
+    valid: boolean;
+    errors?: string[];
+    warnings?: string[];
+}
+
+export interface GraphIntrospectionResult {
+    nodes: Array<{ id: string; type: string; label?: string }>;
+    edges: Array<{ from: string; to: string }>;
+    entrypoints?: string[];
+}
+
+export class GraphsModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * Validate a graph specification.
+     */
+    async validate(body: {
+        graph_spec: {
+            type: string;
+            nodes: Array<{ id: string; type: string; label?: string }>;
+            edges: Array<{ from: string; to: string }>;
+        };
+    }): Promise<APIResponse<GraphValidationResult>> {
+        return this.client.POST<GraphValidationResult>("/v1/api/graphs/validate", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Introspect a graph to get its structure.
+     */
+    async introspect(body: {
+        agent_id?: string;
+        graph_spec?: Record<string, unknown>;
+    }): Promise<APIResponse<GraphIntrospectionResult>> {
+        return this.client.POST<GraphIntrospectionResult>("/v1/api/graphs/introspect", {
+            body,
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/info.ts

@@ -0,0 +1,35 @@
+/**
+ * Info Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse } from "../client/raw.js";
+
+export interface ServerInfo {
+    name: string;
+    version: string;
+    environment: string;
+    features?: string[];
+    uptime_seconds?: number;
+}
+
+export class InfoModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * Get server information.
+     */
+    async get(): Promise<APIResponse<ServerInfo>> {
+        return this.client.GET<ServerInfo>("/v1/api/info", {
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Health check endpoint.
+     */
+    async health(): Promise<APIResponse<{ status: string }>> {
+        return this.client.GET<{ status: string }>("/health", {
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/knowledge.ts

@@ -0,0 +1,147 @@
+/**
+ * Knowledge Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse } from "../client/raw.js";
+
+export interface KnowledgeDataset {
+    id: string;
+    name: string;
+    description?: string;
+    workspace_id: string;
+    file_count: number;
+    total_chunks: number;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface KnowledgeListResponse {
+    items: KnowledgeDataset[];
+    total: number;
+}
+
+export interface KnowledgeFile {
+    id: string;
+    dataset_id: string;
+    filename: string;
+    size_bytes: number;
+    chunk_count: number;
+    status: "pending" | "processing" | "completed" | "failed";
+    created_at: string;
+}
+
+export interface KnowledgeFileListResponse {
+    items: KnowledgeFile[];
+    total: number;
+}
+
+export interface KnowledgeSearchResult {
+    chunk_id: string;
+    file_id: string;
+    content: string;
+    score: number;
+    metadata?: Record<string, unknown>;
+}
+
+export interface KnowledgeSearchResponse {
+    results: KnowledgeSearchResult[];
+    total: number;
+}
+
+export class KnowledgeModule {
+    constructor(
+        private client: RawClient,
+        private getWorkspaceId: () => string,
+        private headers: () => Record<string, string>
+    ) { }
+
+    /**
+     * List all knowledge datasets.
+     */
+    async list(params?: {
+        workspace_id?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<KnowledgeListResponse>> {
+        return this.client.GET<KnowledgeListResponse>("/v1/api/knowledge", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a knowledge dataset by ID.
+     */
+    async get(datasetId: string): Promise<APIResponse<KnowledgeDataset>> {
+        return this.client.GET<KnowledgeDataset>("/v1/api/knowledge/{id}", {
+            params: { path: { id: datasetId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create a new knowledge dataset.
+     */
+    async create(body: {
+        name: string;
+        description?: string;
+    }): Promise<APIResponse<KnowledgeDataset>> {
+        return this.client.POST<KnowledgeDataset>("/v1/api/knowledge", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a knowledge dataset.
+     */
+    async delete(datasetId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/knowledge/{id}", {
+            params: { path: { id: datasetId } },
+            headers: this.headers(),
+        });
+    }
+
+    // ======================== Files ========================
+
+    /**
+     * List files in a dataset.
+     */
+    async listFiles(datasetId: string, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<KnowledgeFileListResponse>> {
+        return this.client.GET<KnowledgeFileListResponse>("/v1/api/knowledge/{id}/files", {
+            params: { path: { id: datasetId }, query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Add a file to a dataset.
+     */
+    async addFile(datasetId: string, fileId: string): Promise<APIResponse<KnowledgeFile>> {
+        return this.client.POST<KnowledgeFile>("/v1/api/knowledge/{id}/files", {
+            params: { path: { id: datasetId } },
+            body: { file_id: fileId },
+            headers: this.headers(),
+        });
+    }
+
+    // ======================== Search ========================
+
+    /**
+     * Search within a knowledge dataset.
+     */
+    async search(datasetId: string, body: {
+        query: string;
+        top_k?: number;
+        min_score?: number;
+    }): Promise<APIResponse<KnowledgeSearchResponse>> {
+        return this.client.POST<KnowledgeSearchResponse>("/v1/api/knowledge/{id}/search", {
+            params: { path: { id: datasetId } },
+            body,
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/mcp.ts

@@ -0,0 +1,59 @@
+/**
+ * MCP Module - Fully Typed (Model Context Protocol)
+ */
+
+import type { RawClient, APIResponse } from "../client/raw.js";
+
+export interface McpServer {
+    id: string;
+    name: string;
+    url: string;
+    status: "connected" | "disconnected" | "error";
+    capabilities?: string[];
+    created_at: string;
+}
+
+export interface McpServerListResponse {
+    items: McpServer[];
+    total: number;
+}
+
+export interface McpToolCallResult {
+    success: boolean;
+    output?: unknown;
+    error?: string;
+}
+
+export class McpModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * List MCP servers.
+     */
+    async listServers(): Promise<APIResponse<McpServerListResponse>> {
+        return this.client.GET<McpServerListResponse>("/v1/api/mcp/servers", {
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get an MCP server.
+     */
+    async getServer(serverId: string): Promise<APIResponse<McpServer>> {
+        return this.client.GET<McpServer>("/v1/api/mcp/servers/{id}", {
+            params: { path: { id: serverId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Call an MCP tool.
+     */
+    async callTool(serverId: string, toolName: string, args: unknown): Promise<APIResponse<McpToolCallResult>> {
+        return this.client.POST<McpToolCallResult>("/v1/api/mcp/servers/{id}/tools/{toolName}/call", {
+            params: { path: { id: serverId, toolName } },
+            body: { arguments: args },
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/me.ts

@@ -0,0 +1,32 @@
+/**
+ * Me Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse } from "../client/raw.js";
+
+export interface MeResponse {
+    user_id: string;
+    email: string;
+    display_name?: string;
+    avatar_url?: string;
+    member_id?: string;
+    tenant_id?: string;
+    workspaces?: {
+        id: string;
+        name: string;
+        role: string;
+    }[];
+}
+
+export class MeModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * Get current user information.
+     */
+    async get(): Promise<APIResponse<MeResponse>> {
+        return this.client.GET<MeResponse>("/v1/api/me", {
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/members.ts

@@ -0,0 +1,117 @@
+/**
+ * Members Module - Fully Typed
+ * 
+ * Naming conventions:
+ * - get* for singular items
+ * - list* for collections
+ * - create*, update*, delete* for mutations (NOT remove!)
+ */
+
+import type { RawClient, APIResponse } from "../client/raw.js";
+import type { PaginationParams, PaginatedResponse } from "../client/helpers.js";
+
+export interface Member {
+    id: string;
+    tenant_id: string;
+    user_id?: string;
+    email?: string;
+    display_name?: string;
+    avatar_url?: string;
+    role_id?: string;
+    role_name?: string;
+    workspace_ids?: string[];
+    status: "active" | "pending" | "disabled";
+    created_at: string;
+    updated_at: string;
+}
+
+export interface MemberInviteResponse {
+    member_id: string;
+    invite_token?: string;
+    email: string;
+}
+
+export type MemberListResponse = PaginatedResponse<Member>;
+
+export class MembersModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * List all members in the tenant.
+     */
+    async list(params?: PaginationParams & {
+        workspace_id?: string;
+        role_id?: string;
+        status?: string;
+    }): Promise<APIResponse<MemberListResponse>> {
+        return this.client.GET<MemberListResponse>("/v1/api/members", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a member by ID.
+     */
+    async get(memberId: string): Promise<APIResponse<Member>> {
+        return this.client.GET<Member>("/v1/api/members/{id}", {
+            params: { path: { id: memberId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Invite a new member.
+     */
+    async invite(body: {
+        email: string;
+        role_id?: string;
+        workspace_ids?: string[];
+    }): Promise<APIResponse<MemberInviteResponse>> {
+        return this.client.POST<MemberInviteResponse>("/v1/api/members/invite", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Update a member.
+     */
+    async update(memberId: string, body: {
+        role_id?: string;
+        workspace_ids?: string[];
+    }): Promise<APIResponse<Member>> {
+        return this.client.PUT<Member>("/v1/api/members/{id}", {
+            params: { path: { id: memberId } },
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Remove a member from the tenant.
+     * Note: Use delete() - remove() is provided as alias for backwards compatibility.
+     */
+    async delete(memberId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/members/{id}", {
+            params: { path: { id: memberId } },
+            headers: this.headers(),
+        });
+    }
+
+    /** 
+     * Alias for delete() (backwards compatibility)
+     * @deprecated Use delete() instead
+     */
+    remove = (memberId: string) => this.delete(memberId);
+
+    /**
+     * Resend invitation email.
+     */
+    async resendInvite(memberId: string): Promise<APIResponse<void>> {
+        return this.client.POST<void>("/v1/api/members/{id}/resend-invite", {
+            params: { path: { id: memberId } },
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/metrics.ts

@@ -0,0 +1,27 @@
+/**
+ * Metrics Module - Fully Typed
+ */
+
+export interface MetricsResponse {
+    raw: string;
+}
+
+export class MetricsModule {
+    constructor(private baseUrl: string, private headers: () => Record<string, string>) { }
+
+    /**
+     * Get Prometheus metrics.
+     */
+    async get(): Promise<MetricsResponse> {
+        const response = await fetch(`${this.baseUrl}/metrics`, {
+            headers: this.headers(),
+        });
+
+        if (!response.ok) {
+            throw new Error(`Failed to fetch metrics: ${response.status}`);
+        }
+
+        const raw = await response.text();
+        return { raw };
+    }
+}

package/src/modules/playground.ts

@@ -0,0 +1,68 @@
+/**
+ * Playground Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse } from "../client/raw.js";
+
+export interface PlaygroundSession {
+    session_id: string;
+    agent_id: string;
+    thread_id: string;
+    status: "active" | "expired";
+    created_at: string;
+    expires_at: string;
+}
+
+export interface PlaygroundMessageResponse {
+    run_id: string;
+    message_id: string;
+    content: string;
+}
+
+export class PlaygroundModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * Create a playground session.
+     */
+    async createSession(body: {
+        agent_id: string;
+        thread_id?: string;
+    }): Promise<APIResponse<PlaygroundSession>> {
+        return this.client.POST<PlaygroundSession>("/v1/api/playground/sessions", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a playground session.
+     */
+    async getSession(sessionId: string): Promise<APIResponse<PlaygroundSession>> {
+        return this.client.GET<PlaygroundSession>("/v1/api/playground/sessions/{id}", {
+            params: { path: { id: sessionId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Send a message in a playground session.
+     */
+    async sendMessage(sessionId: string, message: string): Promise<APIResponse<PlaygroundMessageResponse>> {
+        return this.client.POST<PlaygroundMessageResponse>("/v1/api/playground/sessions/{id}/messages", {
+            params: { path: { id: sessionId } },
+            body: { content: message },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a playground session.
+     */
+    async deleteSession(sessionId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/playground/sessions/{id}", {
+            params: { path: { id: sessionId } },
+            headers: this.headers(),
+        });
+    }
+}