@agent-os-sdk/client 0.1.0

package/src/modules/checkpoints.ts

@@ -0,0 +1,78 @@
+/**
+ * Checkpoints Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+type CheckpointDetail = components["schemas"]["CheckpointDetail"];
+type CheckpointListResponse = components["schemas"]["CheckpointListResponse"];
+
+export interface Checkpoint {
+    id: string;
+    run_id: string;
+    thread_id: string;
+    step_name: string;
+    checkpoint_id: string;
+    parent_checkpoint_id?: string;
+    has_state_snapshot: boolean;
+    created_at: string;
+}
+
+export interface CheckpointNode {
+    id: string;
+    step_name: string;
+    checkpoint_id: string;
+    parent_checkpoint_id?: string;
+    created_at: string;
+    children?: CheckpointNode[];
+}
+
+export interface CheckpointsResponse {
+    run_id: string;
+    total_checkpoints: number;
+    checkpoints: CheckpointNode[];
+}
+
+export interface ReplayResponse {
+    run_id: string;
+    status: string;
+    replayed_from_checkpoint_id: string;
+}
+
+export class CheckpointsModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * List checkpoints for a run.
+     */
+    async list(runId: string): Promise<APIResponse<CheckpointsResponse>> {
+        return this.client.GET<CheckpointsResponse>("/v1/api/runs/{runId}/checkpoints", {
+            params: { path: { runId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a specific checkpoint.
+     */
+    async get(checkpointId: string): Promise<APIResponse<Checkpoint>> {
+        return this.client.GET<Checkpoint>("/v1/api/checkpoints/{id}", {
+            params: { path: { id: checkpointId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Replay from a checkpoint.
+     */
+    async replay(checkpointId: string, options?: {
+        mode?: "best_effort" | "deterministic";
+        modified_state?: unknown;
+    }): Promise<APIResponse<ReplayResponse>> {
+        return this.client.POST<ReplayResponse>("/v1/api/checkpoints/{id}/replay", {
+            params: { path: { id: checkpointId } },
+            body: options ?? {},
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/credentials.ts

@@ -0,0 +1,144 @@
+/**
+ * Credentials Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+type CreateCredentialRequest = components["schemas"]["CreateCredentialRequest"];
+type UpdateCredentialRequest = components["schemas"]["UpdateCredentialRequest"];
+
+export interface Credential {
+    id: string;
+    name: string;
+    scope: "workspace" | "tenant";
+    type_id?: string;
+    type?: string;
+    workspace_id?: string;
+    tenant_id: string;
+    sharing_mode: "private" | "shared";
+    status: "active" | "disabled" | "expired";
+    created_at: string;
+    updated_at: string;
+}
+
+export interface CredentialListResponse {
+    items: Credential[];
+    total: number;
+}
+
+export interface CredentialType {
+    id: string;
+    name: string;
+    schema: Record<string, unknown>;
+    description?: string;
+}
+
+export interface CredentialTypesResponse {
+    items: CredentialType[];
+}
+
+export interface ValidateCredentialResponse {
+    valid: boolean;
+    error?: string;
+}
+
+export class CredentialsModule {
+    constructor(
+        private client: RawClient,
+        private getWorkspaceId: () => string,
+        private headers: () => Record<string, string>
+    ) { }
+
+    /**
+     * List all credentials.
+     */
+    async list(params?: {
+        workspace_id?: string;
+        scope?: string;
+        type?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<CredentialListResponse>> {
+        return this.client.GET<CredentialListResponse>("/v1/api/credentials", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a credential by ID.
+     */
+    async get(credentialId: string): Promise<APIResponse<Credential>> {
+        return this.client.GET<Credential>("/v1/api/credentials/{id}", {
+            params: { path: { id: credentialId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create a new credential.
+     */
+    async create(body: {
+        name: string;
+        scope?: "workspace" | "tenant";
+        type_id?: string;
+        type?: string;
+        workspace_id?: string;
+        values?: Record<string, unknown>;
+        data?: Record<string, unknown>;
+        sharing_mode?: "private" | "shared";
+    }): Promise<APIResponse<Credential>> {
+        return this.client.POST<Credential>("/v1/api/credentials", {
+            body: {
+                ...body,
+                workspace_id: body.workspace_id ?? this.getWorkspaceId(),
+            },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Update a credential.
+     */
+    async update(credentialId: string, body: {
+        name?: string;
+        values?: Record<string, unknown>;
+        status?: string;
+        sharing_mode?: string;
+    }): Promise<APIResponse<Credential>> {
+        return this.client.PUT<Credential>("/v1/api/credentials/{id}", {
+            params: { path: { id: credentialId } },
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a credential.
+     */
+    async delete(credentialId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/credentials/{id}", {
+            params: { path: { id: credentialId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * List available credential types.
+     */
+    async listTypes(): Promise<APIResponse<CredentialTypesResponse>> {
+        return this.client.GET<CredentialTypesResponse>("/v1/api/credentials/types", {
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Validate a credential.
+     */
+    async validate(credentialId: string): Promise<APIResponse<ValidateCredentialResponse>> {
+        return this.client.POST<ValidateCredentialResponse>("/v1/api/credentials/{id}/validate", {
+            params: { path: { id: credentialId } },
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/crons.ts

@@ -0,0 +1,114 @@
+/**
+ * Crons Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+type CreateCronJobRequest = components["schemas"]["CreateCronJobRequest"];
+type UpdateCronJobRequest = components["schemas"]["UpdateCronJobRequest"];
+
+export interface CronJob {
+    id: string;
+    workspace_id: string;
+    agent_id: string;
+    agent_version_id?: string;
+    schedule: string;
+    input?: unknown;
+    enabled: boolean;
+    last_run_at?: string;
+    next_run_at?: string;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface CronJobListResponse {
+    items: CronJob[];
+    total: number;
+}
+
+export interface CronTriggerResponse {
+    run_id: string;
+    triggered_at: string;
+}
+
+export class CronsModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * List all cron jobs.
+     */
+    async list(params?: {
+        workspace_id?: string;
+        agent_id?: string;
+        enabled?: boolean;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<CronJobListResponse>> {
+        return this.client.GET<CronJobListResponse>("/v1/api/crons", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a cron job by ID.
+     */
+    async get(cronId: string): Promise<APIResponse<CronJob>> {
+        return this.client.GET<CronJob>("/v1/api/crons/{id}", {
+            params: { path: { id: cronId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create a new cron job.
+     */
+    async create(body: {
+        workspace_id?: string;
+        agent_id: string;
+        agent_version_id?: string;
+        schedule: string;
+        input?: unknown;
+        enabled?: boolean;
+    }): Promise<APIResponse<CronJob>> {
+        return this.client.POST<CronJob>("/v1/api/crons", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Update a cron job.
+     */
+    async update(cronId: string, body: {
+        schedule?: string;
+        enabled?: boolean;
+        input?: unknown;
+    }): Promise<APIResponse<CronJob>> {
+        return this.client.PUT<CronJob>("/v1/api/crons/{id}", {
+            params: { path: { id: cronId } },
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a cron job.
+     */
+    async delete(cronId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/crons/{id}", {
+            params: { path: { id: cronId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Manually trigger a cron job.
+     */
+    async trigger(cronId: string): Promise<APIResponse<CronTriggerResponse>> {
+        return this.client.POST<CronTriggerResponse>("/v1/api/crons/{id}/trigger", {
+            params: { path: { id: cronId } },
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/dlq.ts

@@ -0,0 +1,93 @@
+/**
+ * DLQ Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse } from "../client/raw.js";
+
+export interface DlqMessage {
+    id: string;
+    workspace_id: string;
+    queue_name: string;
+    original_message: unknown;
+    error_reason: string;
+    retry_count: number;
+    created_at: string;
+    last_retry_at?: string;
+}
+
+export interface DlqListResponse {
+    items: DlqMessage[];
+    total: number;
+}
+
+export interface DlqRetryResponse {
+    success: boolean;
+    message_id: string;
+}
+
+export interface DlqPurgeResponse {
+    deleted_count: number;
+}
+
+export class DlqModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    /**
+     * List DLQ messages.
+     */
+    async list(params?: {
+        workspace_id?: string;
+        queue_name?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<DlqListResponse>> {
+        return this.client.GET<DlqListResponse>("/v1/api/dlq", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a DLQ message by ID.
+     */
+    async get(messageId: string): Promise<APIResponse<DlqMessage>> {
+        return this.client.GET<DlqMessage>("/v1/api/dlq/{id}", {
+            params: { path: { id: messageId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Retry a DLQ message.
+     */
+    async retry(messageId: string): Promise<APIResponse<DlqRetryResponse>> {
+        return this.client.POST<DlqRetryResponse>("/v1/api/dlq/{id}/retry", {
+            params: { path: { id: messageId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a DLQ message.
+     */
+    async delete(messageId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/dlq/{id}", {
+            params: { path: { id: messageId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Purge DLQ messages.
+     */
+    async purge(params?: {
+        workspace_id?: string;
+        queue_name?: string;
+        older_than_days?: number;
+    }): Promise<APIResponse<DlqPurgeResponse>> {
+        return this.client.POST<DlqPurgeResponse>("/v1/api/dlq/purge", {
+            body: params ?? {},
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/evaluation.ts

@@ -0,0 +1,189 @@
+/**
+ * Evaluation Module - Fully Typed
+ */
+
+import type { RawClient, APIResponse, components } from "../client/raw.js";
+
+type CreateDatasetRequest = components["schemas"]["CreateDatasetRequest"];
+type CreateExperimentRequest = components["schemas"]["CreateExperimentRequest"];
+export type ExampleData = components["schemas"]["ExampleData"];
+
+export interface EvalDataset {
+    id: string;
+    name: string;
+    description?: string;
+    workspace_id: string;
+    agent_id?: string;
+    example_count: number;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface DatasetListResponse {
+    items: EvalDataset[];
+    total: number;
+}
+
+export interface Experiment {
+    id: string;
+    dataset_id: string;
+    agent_id: string;
+    agent_version_id?: string;
+    name?: string;
+    status: "pending" | "running" | "completed" | "failed";
+    config?: Record<string, unknown>;
+    results?: ExperimentResults;
+    created_at: string;
+    completed_at?: string;
+}
+
+export interface ExperimentResults {
+    total_examples: number;
+    passed: number;
+    failed: number;
+    metrics?: Record<string, number>;
+}
+
+export interface ExperimentListResponse {
+    items: Experiment[];
+    total: number;
+}
+
+export interface DatasetExample {
+    id: string;
+    dataset_id: string;
+    input: unknown;
+    expected_output?: unknown;
+    metadata?: Record<string, unknown>;
+    created_at: string;
+}
+
+export interface ExamplesListResponse {
+    items: DatasetExample[];
+    total: number;
+}
+
+export class EvaluationModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    // ======================== Datasets ========================
+
+    /**
+     * List all evaluation datasets.
+     */
+    async listDatasets(params?: {
+        workspace_id?: string;
+        agent_id?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<DatasetListResponse>> {
+        return this.client.GET<DatasetListResponse>("/v1/api/evaluation/datasets", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get a dataset by ID.
+     */
+    async getDataset(datasetId: string): Promise<APIResponse<EvalDataset>> {
+        return this.client.GET<EvalDataset>("/v1/api/evaluation/datasets/{id}", {
+            params: { path: { id: datasetId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create a new dataset.
+     */
+    async createDataset(body: {
+        name: string;
+        description?: string;
+        agent_id?: string;
+    }): Promise<APIResponse<EvalDataset>> {
+        return this.client.POST<EvalDataset>("/v1/api/evaluation/datasets", {
+            body,
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Delete a dataset.
+     */
+    async deleteDataset(datasetId: string): Promise<APIResponse<void>> {
+        return this.client.DELETE<void>("/v1/api/evaluation/datasets/{id}", {
+            params: { path: { id: datasetId } },
+            headers: this.headers(),
+        });
+    }
+
+    // ======================== Examples ========================
+
+    /**
+     * List examples in a dataset.
+     */
+    async listExamples(datasetId: string, params?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<ExamplesListResponse>> {
+        return this.client.GET<ExamplesListResponse>("/v1/api/evaluation/datasets/{id}/examples", {
+            params: { path: { id: datasetId }, query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Add examples to a dataset.
+     */
+    async addExamples(datasetId: string, examples: ExampleData[]): Promise<APIResponse<void>> {
+        return this.client.POST<void>("/v1/api/evaluation/datasets/{id}/examples", {
+            params: { path: { id: datasetId } },
+            body: { examples },
+            headers: this.headers(),
+        });
+    }
+
+    // ======================== Experiments ========================
+
+    /**
+     * List all experiments.
+     */
+    async listExperiments(params?: {
+        dataset_id?: string;
+        agent_id?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<ExperimentListResponse>> {
+        return this.client.GET<ExperimentListResponse>("/v1/api/evaluation/experiments", {
+            params: { query: params },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Get an experiment by ID.
+     */
+    async getExperiment(experimentId: string): Promise<APIResponse<Experiment>> {
+        return this.client.GET<Experiment>("/v1/api/evaluation/experiments/{id}", {
+            params: { path: { id: experimentId } },
+            headers: this.headers(),
+        });
+    }
+
+    /**
+     * Create a new experiment.
+     */
+    async createExperiment(body: {
+        dataset_id: string;
+        agent_id: string;
+        agent_version_id?: string;
+        name?: string;
+        config?: Record<string, unknown>;
+    }): Promise<APIResponse<Experiment>> {
+        return this.client.POST<Experiment>("/v1/api/evaluation/experiments", {
+            body,
+            headers: this.headers(),
+        });
+    }
+}