@agent-os-sdk/client 0.1.0

package/src/modules/prompts.ts

@@ -0,0 +1,147 @@
+/**
+ * Prompts Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+type CreatePromptRequest = components["schemas"]["CreatePromptRequest"];
+type CreatePromptVersionRequest = components["schemas"]["CreatePromptVersionRequest"];
+
+export interface Prompt {
+    id: string;
+    name: string;
+    description?: string;
+    workspace_id: string;
+    tenant_id: string;
+    created_at: string;
+    updated_at: string;
+    versions?: PromptVersion[];
+}
+
+export interface PromptVersion {
+    id: string;
+    prompt_id: string;
+    version: number;
+    template: string;
+    input_schema?: Record<string, unknown>;
+    output_schema?: Record<string, unknown>;
+    is_live: boolean;
+    created_at: string;
+}
+
+export interface PromptListResponse {
+    items: Prompt[];
+    total: number;
+}
+
+export interface PromptVersionListResponse {
+    items: PromptVersion[];
+    total: number;
+}
+
+export interface RenderPromptResponse {
+    rendered: string;
+    input_used: Record<string, unknown>;
+}
+
+export class PromptsModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * List all prompts.
+     */
+    async list(params?: {
+        workspace_id?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<PromptListResponse>> {
+        return this.client.GET<PromptListResponse>("/v1/api/prompts", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a prompt by ID.
+     */
+    async get(promptId: string): Promise<APIResponse<Prompt>> {
+        return this.client.GET<Prompt>("/v1/api/prompts/{id}", {
+            params: { path: { id: promptId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create a new prompt.
+     */
+    async create(body: {
+        name: string;
+        description?: string;
+        template?: string;
+        input_schema?: Record<string, unknown>;
+    }): Promise<APIResponse<Prompt>> {
+        return this.client.POST<Prompt>("/v1/api/prompts", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a prompt.
+     */
+    async delete(promptId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/prompts/{id}", {
+            params: { path: { id: promptId } },
+            headers: this.headers(),
+        });
+    }
+
+    // ======================== Versions ========================
+
+    /**
+     * List all versions of a prompt.
+     */
+    async listVersions(promptId: string): Promise<APIResponse<PromptVersionListResponse>> {
+        return this.client.GET<PromptVersionListResponse>("/v1/api/prompts/{id}/versions", {
+            params: { path: { id: promptId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create a new version.
+     */
+    async createVersion(promptId: string, body: {
+        template: string;
+        input_schema?: Record<string, unknown>;
+        output_schema?: Record<string, unknown>;
+    }): Promise<APIResponse<PromptVersion>> {
+        return this.client.POST<PromptVersion>("/v1/api/prompts/{id}/versions", {
+            params: { path: { id: promptId } },
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Set the live version.
+     */
+    async setLiveVersion(promptId: string, versionNumber: number): Promise<APIResponse<void>> {
+        return this.client.POST<void>("/v1/api/prompts/{id}/set-live", {
+            params: { path: { id: promptId } },
+            body: { version_number: versionNumber },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Render a prompt with variables.
+     */
+    async render(promptId: string, variables: Record<string, unknown>): Promise<APIResponse<RenderPromptResponse>> {
+        return this.client.POST<RenderPromptResponse>("/v1/api/prompts/{id}/render", {
+            params: { path: { id: promptId } },
+            body: { variables },
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/runs.ts

@@ -0,0 +1,277 @@
+/**
+ * Runs Module - Core execution API (Fully Typed)
+ * 
+ * Naming conventions:
+ * - get* for singular items
+ * - list* for collections  
+ * - create*, update*, delete* for mutations
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+import type { PaginationParams, PaginatedResponse } from "../client/helpers.js";
+import { streamSSE, type SSEEvent, type RunStreamEvent, type SSEOptions } from "../sse/client.js";
+
+// Type aliases from OpenAPI
+type WaitRunResponse = components["schemas"]["WaitRunResponse"];
+type BatchRunResponse = components["schemas"]["BatchRunResponse"];
+type CancelRunResponse = components["schemas"]["CancelRunResponse"];
+type CheckpointListResponse = components["schemas"]["CheckpointListResponse"];
+
+// Response types
+export interface Run {
+    run_id: string;
+    status: "pending" | "running" | "completed" | "failed" | "cancelled" | "waiting_input";
+    thread_id?: string;
+    agent_id: string;
+    agent_version_id?: string;
+    tenant_id: string;
+    workspace_id: string;
+    input?: unknown;
+    output?: unknown;
+    error?: unknown;
+    created_at: string;
+    started_at?: string;
+    completed_at?: string;
+    duration_ms?: number;
+    reused?: boolean;
+}
+
+export interface RunEvent {
+    id: string;
+    run_id: string;
+    event_type: string;
+    node?: string;
+    data?: unknown;
+    timestamp: string;
+}
+
+export interface CreateRunResponse {
+    run_id: string;
+    status: string;
+    reused?: boolean;
+}
+
+export type RunListResponse = PaginatedResponse<Run>;
+export type RunEventsResponse = PaginatedResponse<RunEvent>;
+
+export class RunsModule {
+    constructor(
+        private client: RawClient,
+        private baseUrl: string,
+        private headers: () => Record<string, string>
+    ) { }
+
+    // ======================== CRUD ========================
+
+    /**
+     * Create a new run.
+     * @example
+     * ```ts
+     * const { data } = await client.runs.create({
+     *   agent_id: "agent-uuid",
+     *   input: { message: "Hello" }
+     * });
+     * ```
+     */
+    async create(body: {
+        agent_id: string;
+        thread?: { thread_id?: string } | { new_thread: true };
+        input?: unknown;
+        idempotency_key?: string;
+    }): Promise<APIResponse<CreateRunResponse>> {
+        return this.client.POST<CreateRunResponse>("/v1/api/runs", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a run by ID.
+     */
+    async get(runId: string): Promise<APIResponse<Run>> {
+        return this.client.GET<Run>("/v1/api/runs/{runId}", {
+            params: { path: { runId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * List runs with optional filters.
+     */
+    async list(params?: PaginationParams & {
+        thread_id?: string;
+        agent_id?: string;
+        status?: string;
+    }): Promise<APIResponse<RunListResponse>> {
+        return this.client.GET<RunListResponse>("/v1/api/runs", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    // ======================== Execution ========================
+
+    /**
+     * Wait for run completion synchronously.
+     */
+    async wait(body: {
+        agent_id: string;
+        thread?: { thread_id?: string } | { new_thread: true };
+        input?: unknown;
+        timeout_seconds?: number;
+    }): Promise<APIResponse<WaitRunResponse>> {
+        return this.client.POST<WaitRunResponse>("/v1/api/runs/wait", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create batch runs.
+     */
+    async batch(body: {
+        agent_id: string;
+        inputs: Array<{ input: unknown; idempotency_key?: string }>;
+    }): Promise<APIResponse<BatchRunResponse>> {
+        return this.client.POST<BatchRunResponse>("/v1/api/runs/batch", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Cancel a running run.
+     */
+    async cancel(runId: string, reason?: string): Promise<APIResponse<CancelRunResponse>> {
+        return this.client.POST<CancelRunResponse>("/v1/api/runs/{runId}/cancel", {
+            params: { path: { runId } },
+            body: { reason },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Resume a run waiting for human input (HITL).
+     */
+    async resume(runId: string, input: unknown): Promise<APIResponse<Run>> {
+        return this.client.POST<Run>("/v1/api/runs/{runId}/resume", {
+            params: { path: { runId } },
+            body: { input },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Rerun from start (stateless).
+     */
+    async rerun(runId: string): Promise<APIResponse<CreateRunResponse>> {
+        return this.client.POST<CreateRunResponse>("/v1/api/runs/{runId}/rerun", {
+            params: { path: { runId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Replay from checkpoint (stateful).
+     */
+    async replay(runId: string, checkpointId?: string, mode?: "best_effort" | "deterministic"): Promise<APIResponse<CreateRunResponse>> {
+        return this.client.POST<CreateRunResponse>("/v1/api/runs/{runId}/replay", {
+            params: { path: { runId } },
+            body: { checkpoint_id: checkpointId, mode },
+            headers: this.headers(),
+        });
+    }
+
+    // ======================== Events ========================
+
+    /**
+     * Get run events for timeline (paged, no SSE).
+     * @example
+     * ```ts
+     * const { data } = await client.runs.getEvents("run-uuid");
+     * ```
+     */
+    async getEvents(runId: string, params?: PaginationParams): Promise<APIResponse<RunEventsResponse>> {
+        return this.client.GET<RunEventsResponse>("/v1/api/runs/{runId}/events", {
+            params: { path: { runId }, query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /** Alias: runs.events() -> runs.getEvents() */
+    events = (runId: string, params?: PaginationParams) => this.getEvents(runId, params);
+
+    // ======================== Checkpoints ========================
+
+    /**
+     * Get checkpoints for a run.
+     */
+    async getCheckpoints(runId: string): Promise<APIResponse<CheckpointListResponse>> {
+        return this.client.GET<CheckpointListResponse>("/v1/api/runs/{runId}/checkpoints", {
+            params: { path: { runId } },
+            headers: this.headers(),
+        });
+    }
+
+    /** Alias: runs.checkpoints() -> runs.getCheckpoints() */
+    checkpoints = (runId: string) => this.getCheckpoints(runId);
+
+    // ======================== STREAMING ========================
+
+    /**
+     * Stream run events via SSE.
+     * @example
+     * ```ts
+     * for await (const event of client.runs.stream("run-uuid")) {
+     *   console.log(event.data);
+     * }
+     * ```
+     */
+    stream(runId: string, options?: SSEOptions): AsyncGenerator<SSEEvent<RunStreamEvent>> {
+        const url = `${this.baseUrl}/v1/api/runs/${runId}/stream`;
+        return streamSSE<RunStreamEvent>(url, {
+            ...options,
+            headers: { ...this.headers(), ...options?.headers },
+        });
+    }
+
+    /**
+     * Create run and stream output.
+     * @example
+     * ```ts
+     * for await (const event of client.runs.createAndStream({
+     *   agent_id: "...",
+     *   input: { message: "Hello" }
+     * })) {
+     *   console.log(event);
+     * }
+     * ```
+     */
+    async *createAndStream(
+        body: {
+            agent_id: string;
+            thread?: { thread_id?: string } | { new_thread: true };
+            input?: unknown;
+        },
+        options?: SSEOptions
+    ): AsyncGenerator<SSEEvent<RunStreamEvent>> {
+        const { data, error } = await this.create(body);
+        if (error || !data) {
+            throw new Error(`Failed to create run: ${JSON.stringify(error)}`);
+        }
+
+        const runId = data.run_id;
+        yield* this.stream(runId, options);
+    }
+
+    /**
+     * Join an existing run's stream (resume watching).
+     */
+    join(runId: string, options?: SSEOptions): AsyncGenerator<SSEEvent<RunStreamEvent>> {
+        const url = `${this.baseUrl}/v1/api/runs/${runId}/join`;
+        return streamSSE<RunStreamEvent>(url, {
+            ...options,
+            headers: { ...this.headers(), ...options?.headers },
+        });
+    }
+}

package/src/modules/store.ts

@@ -0,0 +1,65 @@
+/**
+ * Store Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+type StoreValueRequest = components["schemas"]["StoreValueRequest"];
+
+export interface StoreValue {
+    key: string;
+    value: string;
+    ttl_seconds?: number;
+    created_at: string;
+    expires_at?: string;
+}
+
+export interface StoreKeysResponse {
+    keys: string[];
+    total: number;
+}
+
+export class StoreModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * Get a value by key.
+     */
+    async get(key: string): Promise<APIResponse<StoreValue>> {
+        return this.client.GET<StoreValue>("/v1/api/store/{key}", {
+            params: { path: { key } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Set a value.
+     */
+    async set(key: string, value: string, ttlSeconds?: number): Promise<APIResponse<StoreValue>> {
+        return this.client.PUT<StoreValue>("/v1/api/store/{key}", {
+            params: { path: { key } },
+            body: { value, ttl_seconds: ttlSeconds },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a value.
+     */
+    async delete(key: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/store/{key}", {
+            params: { path: { key } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * List all keys.
+     */
+    async listKeys(prefix?: string): Promise<APIResponse<StoreKeysResponse>> {
+        return this.client.GET<StoreKeysResponse>("/v1/api/store", {
+            params: { query: { prefix } },
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/tenants.ts

@@ -0,0 +1,67 @@
+/**
+ * Tenants Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+type UpdateTenantRequest = components["schemas"]["UpdateTenantRequest"];
+
+export interface Tenant {
+    id: string;
+    name: string;
+    slug: string;
+    owner_id?: string;
+    settings?: Record<string, unknown>;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface TenantListResponse {
+    items: Tenant[];
+    total: number;
+}
+
+export class TenantsModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * Get the current tenant.
+     */
+    async get(): Promise<APIResponse<Tenant>> {
+        return this.client.GET<Tenant>("/v1/api/tenants/current", {
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Update the current tenant.
+     */
+    async update(body: {
+        name?: string;
+        slug?: string;
+    }): Promise<APIResponse<Tenant>> {
+        return this.client.PUT<Tenant>("/v1/api/tenants/current", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get tenant settings.
+     */
+    async getSettings(): Promise<APIResponse<Record<string, unknown>>> {
+        return this.client.GET<Record<string, unknown>>("/v1/api/tenants/current/settings", {
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Update tenant settings.
+     */
+    async updateSettings(settings: Record<string, unknown>): Promise<APIResponse<void>> {
+        return this.client.PUT<void>("/v1/api/tenants/current/settings", {
+            body: settings,
+            headers: this.headers(),
+        });
+    }
+}