@agent-os-sdk/client 0.9.25 → 0.9.27

package/src/modules/memberships.ts

@@ -1,42 +0,0 @@
-
-import type { RawClient, APIResponse } from "../client/raw.js";
-
-export interface MembershipResponse {
-    id: string;
-    user_id: string;
-    tenant_id: string;
-    role_id: string;
-    role_name?: string;
-    workspace_id?: string;
-    workspace_name?: string;
-    created_at: string;
-}
-
-export interface EnsureMembershipRequest {
-    tenant_id?: string;
-    workspace_id?: string;
-}
-
-export class MembershipsModule {
-    private client: RawClient;
-
-    constructor(client: RawClient) {
-        this.client = client;
-    }
-
-    private headers() {
-        return {
-            "Content-Type": "application/json",
-        };
-    }
-
-    /**
-     * Ensure the current user has a membership in a tenant (self-provisioning).
-     */
-    async ensure(body: EnsureMembershipRequest): Promise<APIResponse<MembershipResponse>> {
-        return this.client.POST<MembershipResponse>("/v1/api/memberships/ensure", {
-            body,
-            headers: this.headers(),
-        });
-    }
-}

package/src/modules/metaAgent.ts

@@ -1,131 +0,0 @@
-import type { APIResponse, RawClient } from "../client/raw.js";
-
-export interface MetaAgentPatchValidationIssue {
-    code: string;
-    message: string;
-    node_id?: string | null;
-    path?: string | null;
-}
-
-export interface MetaAgentPreviewValidationIssue {
-    code: string;
-    message: string;
-    path?: string | null;
-    severity?: string | null;
-}
-
-export interface MetaAgentPatchOp {
-    op: string;
-    node_id?: string | null;
-    capability_ref?: string | null;
-    capability_version?: string | null;
-    label?: string | null;
-    data?: Record<string, unknown> | null;
-    set?: Record<string, unknown> | null;
-    from?: string | null;
-    to?: string | null;
-    entrypoint?: string | null;
-}
-
-export interface MetaAgentPatchProposal {
-    patch_id: string;
-    description?: string | null;
-    ops: MetaAgentPatchOp[];
-}
-
-export interface MetaAgentDiffPreview {
-    added_node_ids: string[];
-    removed_node_ids: string[];
-    updated_node_ids: string[];
-    added_edge_ids: string[];
-    removed_edge_ids: string[];
-    entrypoint_changed: boolean;
-    before_entrypoint?: string | null;
-    after_entrypoint?: string | null;
-}
-
-export interface MetaAgentBlastRadiusCredentialImpact {
-    required_credential: string;
-    status: "bound" | "missing";
-    binding_key?: string | null;
-    credential_instance_ref?: string | null;
-    credential_name?: string | null;
-}
-
-export interface MetaAgentBlastRadius {
-    affected_node_ids: string[];
-    affected_edge_ids: string[];
-    added_capabilities: string[];
-    removed_capabilities: string[];
-    changed_capabilities: string[];
-    impacted_credentials: MetaAgentBlastRadiusCredentialImpact[];
-    warnings: MetaAgentPreviewValidationIssue[];
-}
-
-export interface MetaAgentValidationResult {
-    valid: boolean;
-    preview_valid: boolean;
-    errors: MetaAgentPatchValidationIssue[];
-    warnings: MetaAgentPreviewValidationIssue[];
-}
-
-export interface MetaAgentPatchProposalResponse {
-    agent_id: string;
-    draft_revision?: string | null;
-    draft_etag: string;
-    source_contract: "agent_ir.v1";
-    mode?: "chat" | "proposal";
-    patch?: MetaAgentPatchProposal | null;
-    preview_draft_ir?: Record<string, unknown> | null;
-    diff_preview?: MetaAgentDiffPreview | null;
-    blast_radius?: MetaAgentBlastRadius | null;
-    validation_result: MetaAgentValidationResult;
-    message: string;
-}
-
-export interface MetaAgentApplyPatchResponse {
-    agent_id: string;
-    draft_revision?: string | null;
-    draft_etag_before: string;
-    draft_etag_after: string;
-    patch_id: string;
-    source_contract: "agent_ir.v1";
-    applied_at: string;
-    applied_by?: string | null;
-    draft_ir: Record<string, unknown>;
-}
-
-export class MetaAgentModule {
-    constructor(private client: RawClient, private headers: () => Record<string, string>) {}
-
-    async chat(agentId: string, message: string): Promise<APIResponse<MetaAgentPatchProposalResponse>> {
-        return this.client.POST<MetaAgentPatchProposalResponse>("/v1/api/agents/{id}/meta-agent/chat", {
-            params: { path: { id: agentId } },
-            headers: this.headers(),
-            body: { message },
-        });
-    }
-
-    async propose(agentId: string, instruction: string): Promise<APIResponse<MetaAgentPatchProposalResponse>> {
-        return this.client.POST<MetaAgentPatchProposalResponse>("/v1/api/agents/{id}/meta-agent/proposals", {
-            params: { path: { id: agentId } },
-            headers: this.headers(),
-            body: { instruction },
-        });
-    }
-
-    async apply(
-        agentId: string,
-        draftEtag: string,
-        patch: MetaAgentPatchProposal,
-    ): Promise<APIResponse<MetaAgentApplyPatchResponse>> {
-        return this.client.POST<MetaAgentApplyPatchResponse>("/v1/api/agents/{id}/meta-agent/proposals/apply", {
-            params: { path: { id: agentId } },
-            headers: this.headers(),
-            body: {
-                draft_etag: draftEtag,
-                patch,
-            },
-        });
-    }
-}

package/src/modules/metrics.ts

@@ -1,34 +0,0 @@
-/**
- * Metrics Module - Fully Typed
- * 
- * ALL HTTP goes through rawClient - no direct fetch calls.
- */
-
-import type { RawClient } from "../client/raw.js";
-
-export interface MetricsResponse {
-    raw: string;
-}
-
-export class MetricsModule {
-    constructor(private client: RawClient) { }
-
-    /**
-     * Get Prometheus metrics.
-     * 
-     * Uses rawClient - headers resolved asynchronously.
-     */
-    async get(): Promise<MetricsResponse> {
-        // Use streamGet for raw text response (metrics endpoint returns text/plain)
-        const response = await this.client.streamGet("/metrics", {
-            headers: { Accept: "text/plain" }
-        });
-
-        if (!response.ok) {
-            throw new Error(`Failed to fetch metrics: ${response.status}`);
-        }
-
-        const raw = await response.text();
-        return { raw };
-    }
-}

package/src/modules/observability.ts

@@ -1,28 +0,0 @@
-import type { APIResponse, RawClient } from "../client/raw.js";
-
-export type FrontendLogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
-
-export interface FrontendLogPayload {
-    level: FrontendLogLevel;
-    message: string;
-    stack?: string;
-    route?: string;
-    url?: string;
-    user_agent?: string;
-    session_id?: string;
-    context?: Record<string, unknown>;
-}
-
-export class ObservabilityModule {
-    constructor(
-        private client: RawClient,
-        private headers: () => Record<string, string>
-    ) { }
-
-    async logFrontend(payload: FrontendLogPayload): Promise<APIResponse<Record<string, unknown>>> {
-        return this.client.POST<Record<string, unknown>>("/v1/api/observability/frontend-log", {
-            body: payload,
-            headers: this.headers(),
-        });
-    }
-}

package/src/modules/playground.ts

@@ -1,68 +0,0 @@
-/**
- * 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(),
-        });
-    }
-}

package/src/modules/presets.ts

@@ -1,246 +0,0 @@
-import type { RawClient } from "../client/raw.js";
-import { AgentsModule } from "./agents.js";
-import { TriggersModule } from "./triggers.js";
-
-export interface AgentTemplateConfig {
-  name: string;
-  trigger_type: "chatwoot" | "webhook" | "schedule";
-  output_type: "chatwoot" | "http";
-  llm?: {
-    credential_id?: string;
-    model?: string;
-    instructions?: string;
-  };
-  bindings?: Array<{
-    credential_id: string;
-    alias: string;
-  }>;
-}
-
-export interface CreatedAgentResult {
-  agent_id: string;
-  agent_name: string;
-  bundle_id?: string;
-  trigger_id?: string;
-  trigger_url?: string;
-  status: "live" | "draft";
-}
-
-const TRIGGER_TYPE_MAP: Record<string, { type: string; template_slug: string }> = {
-  chatwoot: { type: "webhook", template_slug: "chatwoot" },
-  webhook: { type: "webhook", template_slug: "generic" },
-  schedule: { type: "schedule", template_slug: "cron" },
-};
-
-function buildAgentDefinitionId(name: string): string {
-  const normalized = name
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, ".")
-    .replace(/\.{2,}/g, ".")
-    .replace(/^\.|\.$/g, "");
-  return `agent.${normalized || "untitled"}`;
-}
-
-function generateAgentIr(config: AgentTemplateConfig): Record<string, unknown> {
-  const agentDefinitionId = buildAgentDefinitionId(config.name);
-  const triggerLabel = config.trigger_type === "schedule" ? "Scheduled Trigger" : "Incoming Trigger";
-  const outputLabel = config.output_type === "chatwoot" ? "Chatwoot Output" : "HTTP Output";
-
-  return {
-    ir_version: "1.0",
-    agent_definition_id: agentDefinitionId,
-    version: "1.0.0",
-    metadata: {
-      name: config.name,
-      description: "Preset-generated agent_ir.v1 draft",
-    },
-    state_schema: {
-      type: "object",
-      properties: {
-        global: {
-          type: "object",
-        },
-      },
-    },
-    inputs_schema: {
-      type: "object",
-      properties: {
-        message: {
-          type: "string",
-        },
-      },
-      required: ["message"],
-    },
-    outputs_schema: {
-      type: "object",
-    },
-    outcome_schema: {
-      type: "object",
-      properties: {
-        preset_ready: {
-          type: "boolean",
-        },
-      },
-      required: ["preset_ready"],
-    },
-    kpi_bindings: [
-      {
-        kpi_ref: `${agentDefinitionId}.preset_ready`,
-        source_scope: "outcome",
-        source_path: "preset_ready",
-      },
-    ],
-    evaluation_policy: {
-      execution_mode: "async",
-      evaluators: [
-        {
-          evaluator_ref: `eval.${agentDefinitionId}.preset_shape_v1`,
-          kind: "rule",
-        },
-      ],
-      sampling_policy: {
-        mode: "all",
-      },
-    },
-    improvement_policy_ref: null,
-    nodes: [
-      {
-        id: "start",
-        kind: "start",
-        capability_ref: "capability://agent-ir/start",
-        label: triggerLabel,
-        config: {},
-        bindings: {},
-        editability: { mode: "read_only" },
-      },
-      {
-        id: "draft_output",
-        kind: "end",
-        capability_ref: "capability://agent-ir/end",
-        label: outputLabel,
-        config: {},
-        bindings: {},
-        editability: { mode: "full" },
-      },
-    ],
-    edges: [
-      {
-        id: "edge_start_to_output",
-        from: "start",
-        to: "draft_output",
-        kind: "default",
-        priority: 0,
-      },
-    ],
-    capability_registry_refs: [],
-    policies: {},
-    editability: {
-      mode: "full",
-    },
-    entrypoints: ["start"],
-  };
-}
-
-
-function generateUUID(): string {
-  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
-    return crypto.randomUUID();
-  }
-  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
-    var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8);
-    return v.toString(16);
-  });
-}
-
-export class PresetsModule {
-  private _client: RawClient;
-  private _headers: () => Record<string, string>;
-
-  // Internal modules needed for orchestration
-  private _agents: AgentsModule;
-  private _triggers: TriggersModule;
-
-  constructor(client: RawClient, getHeaders: () => Record<string, string>) {
-    this._client = client;
-    this._headers = getHeaders;
-    this._agents = new AgentsModule(client, getHeaders);
-    this._triggers = new TriggersModule(client, getHeaders);
-  }
-
-  async createAgent(config: AgentTemplateConfig): Promise<CreatedAgentResult | null> {
-    try {
-      console.log("[AgentOS SDK] Creating agent from preset...", {
-        name: config.name,
-        trigger_type: config.trigger_type,
-        output_type: config.output_type,
-      });
-
-      const { data: agent, error: createError } = await this._agents.create({
-        name: config.name,
-        idempotency_key: generateUUID()
-      });
-
-      if (createError || !agent) {
-        console.error("[AgentOS SDK] Failed to create agent:", createError);
-        return null;
-      }
-
-      const { error: draftError } = await this._agents.updateDraftIr(
-        agent.id,
-        generateAgentIr(config),
-        { if_match: `"${agent.id}:0"` },
-      );
-
-      if (draftError) {
-        console.error("[AgentOS SDK] Failed to save agent_ir.v1 draft:", draftError);
-        return {
-          agent_id: agent.id,
-          agent_name: agent.name,
-          status: "draft",
-        };
-      }
-
-      const { data: bundle, error: publishError } = await this._agents.publish(agent.id, {
-        set_as_live: true,
-        required_tools: [],
-        idempotency_key: generateUUID(),
-      });
-
-      if (publishError) {
-        console.error("[AgentOS SDK] Failed to publish bundle:", publishError);
-        return {
-          agent_id: agent.id,
-          agent_name: agent.name,
-          status: "draft",
-        };
-      }
-
-      const triggerMapping = TRIGGER_TYPE_MAP[config.trigger_type] ?? TRIGGER_TYPE_MAP.webhook;
-      if (!triggerMapping) throw new Error("Trigger mapping failed");
-
-      const { data: trigger, error: triggerError } = await this._triggers.create({
-        name: `${config.name} - ${config.trigger_type}`,
-        agent_id: agent.id,
-        trigger_type: triggerMapping.type,
-        template_slug: triggerMapping.template_slug,
-      });
-
-      if (triggerError) {
-        console.warn("[AgentOS SDK] Failed to create trigger:", triggerError);
-      }
-
-      return {
-        agent_id: agent.id,
-        agent_name: agent.name,
-        bundle_id: bundle?.id,
-        trigger_id: trigger?.id,
-        trigger_url: (trigger as any)?.invoke_url,
-        status: "live",
-      };
-    } catch (err) {
-      console.error("[AgentOS SDK] Exception creating agent from preset:", err);
-      return null;
-    }
-  }
-}

package/src/modules/prompts.ts

@@ -1,147 +0,0 @@
-/**
- * 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(),
-        });
-    }
-}