@agent-os-sdk/client 0.1.0 → 0.1.2

package/src/modules/incidents.ts

@@ -0,0 +1,339 @@
+/**
+ * Incidents Module - Operational Incidents & Postmortems
+ * 
+ * // MOCK - This module contains mock implementations for future features
+ * 
+ * Provides incident management, SLO tracking, and postmortem creation.
+ * Brings Datadog vibes to agent operations.
+ */
+
+import type { RawClient, APIResponse } from "../client/raw.js";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type IncidentSeverity = "critical" | "major" | "minor" | "warning";
+export type IncidentStatus = "open" | "investigating" | "identified" | "monitoring" | "resolved";
+
+export interface Incident {
+    id: string;
+    title: string;
+    description: string;
+    severity: IncidentSeverity;
+    status: IncidentStatus;
+    affected_agents: string[];
+    affected_runs: string[];
+    root_cause?: string;
+    resolution?: string;
+    created_at: string;
+    updated_at: string;
+    resolved_at?: string;
+    created_by: string;
+}
+
+export interface SLO {
+    id: string;
+    name: string;
+    description?: string;
+    target_percentage: number;
+    current_percentage: number;
+    metric_type: "availability" | "latency" | "error_rate" | "success_rate";
+    threshold?: number;
+    window_days: number;
+    status: "healthy" | "at_risk" | "breached";
+    budget_remaining: number;
+    created_at: string;
+}
+
+export interface Postmortem {
+    id: string;
+    incident_id: string;
+    title: string;
+    summary: string;
+    timeline: PostmortemEvent[];
+    root_cause_analysis: string;
+    impact: string;
+    action_items: ActionItem[];
+    lessons_learned: string[];
+    created_at: string;
+    created_by: string;
+}
+
+export interface PostmortemEvent {
+    timestamp: string;
+    description: string;
+    actor?: string;
+}
+
+export interface ActionItem {
+    id: string;
+    description: string;
+    owner: string;
+    due_date?: string;
+    status: "open" | "in_progress" | "completed";
+}
+
+export interface IncidentListResponse {
+    items: Incident[];
+    total: number;
+    open_count: number;
+}
+
+export interface SLOListResponse {
+    items: SLO[];
+    total: number;
+}
+
+// ============================================================================
+// Module
+// ============================================================================
+
+export class IncidentsModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    // ========== Incidents ==========
+
+    // MOCK - Simulated list
+    /**
+     * List all incidents.
+     */
+    async list(params?: {
+        status?: IncidentStatus;
+        severity?: IncidentSeverity;
+    }): Promise<APIResponse<IncidentListResponse>> {
+        // MOCK - Returns simulated data
+        const mockIncidents: IncidentListResponse = {
+            items: [
+                {
+                    id: "inc_1",
+                    title: "High error rate on Support Agent",
+                    description: "Error rate exceeded 5% threshold",
+                    severity: "major",
+                    status: "investigating",
+                    affected_agents: ["agent_support"],
+                    affected_runs: ["run_123", "run_124", "run_125"],
+                    created_at: new Date(Date.now() - 3600000).toISOString(),
+                    updated_at: new Date().toISOString(),
+                    created_by: "system",
+                },
+            ],
+            total: 1,
+            open_count: 1,
+        };
+        return { data: mockIncidents, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated get
+    /**
+     * Get an incident by ID.
+     */
+    async get(incidentId: string): Promise<APIResponse<Incident>> {
+        // MOCK - Returns simulated data
+        const mockIncident: Incident = {
+            id: incidentId,
+            title: "High error rate on Support Agent",
+            description: "Error rate exceeded 5% threshold",
+            severity: "major",
+            status: "investigating",
+            affected_agents: ["agent_support"],
+            affected_runs: ["run_123", "run_124", "run_125"],
+            created_at: new Date(Date.now() - 3600000).toISOString(),
+            updated_at: new Date().toISOString(),
+            created_by: "system",
+        };
+        return { data: mockIncident, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated create
+    /**
+     * Create a new incident.
+     */
+    async create(body: {
+        title: string;
+        description: string;
+        severity: IncidentSeverity;
+        affected_agents?: string[];
+    }): Promise<APIResponse<Incident>> {
+        // MOCK - Returns simulated data
+        const mockIncident: Incident = {
+            id: `inc_${Date.now()}`,
+            title: body.title,
+            description: body.description,
+            severity: body.severity,
+            status: "open",
+            affected_agents: body.affected_agents || [],
+            affected_runs: [],
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+            created_by: "user_current",
+        };
+        return { data: mockIncident, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated resolve
+    /**
+     * Resolve an incident.
+     */
+    async resolve(incidentId: string, resolution: string): Promise<APIResponse<Incident>> {
+        // MOCK - Returns simulated data
+        const mockIncident: Incident = {
+            id: incidentId,
+            title: "High error rate on Support Agent",
+            description: "Error rate exceeded 5% threshold",
+            severity: "major",
+            status: "resolved",
+            affected_agents: ["agent_support"],
+            affected_runs: [],
+            root_cause: "Model provider rate limit",
+            resolution,
+            created_at: new Date(Date.now() - 7200000).toISOString(),
+            updated_at: new Date().toISOString(),
+            resolved_at: new Date().toISOString(),
+            created_by: "system",
+        };
+        return { data: mockIncident, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated linkRuns
+    /**
+     * Link runs to an incident.
+     */
+    async linkRuns(incidentId: string, runIds: string[]): Promise<APIResponse<Incident>> {
+        // MOCK - Returns simulated data
+        const mockIncident: Incident = {
+            id: incidentId,
+            title: "High error rate on Support Agent",
+            description: "Error rate exceeded 5% threshold",
+            severity: "major",
+            status: "investigating",
+            affected_agents: ["agent_support"],
+            affected_runs: runIds,
+            created_at: new Date(Date.now() - 3600000).toISOString(),
+            updated_at: new Date().toISOString(),
+            created_by: "system",
+        };
+        return { data: mockIncident, error: undefined, response: new Response() };
+    }
+
+    // ========== SLOs ==========
+
+    // MOCK - Simulated listSLOs
+    /**
+     * List all SLOs.
+     */
+    async listSLOs(): Promise<APIResponse<SLOListResponse>> {
+        // MOCK - Returns simulated data
+        const mockSLOs: SLOListResponse = {
+            items: [
+                {
+                    id: "slo_availability",
+                    name: "Agent Availability",
+                    description: "99.9% availability for all agents",
+                    target_percentage: 99.9,
+                    current_percentage: 99.95,
+                    metric_type: "availability",
+                    window_days: 30,
+                    status: "healthy",
+                    budget_remaining: 0.05,
+                    created_at: new Date(Date.now() - 86400000 * 30).toISOString(),
+                },
+                {
+                    id: "slo_latency",
+                    name: "Response Latency",
+                    description: "P95 latency under 2s",
+                    target_percentage: 95,
+                    current_percentage: 97.5,
+                    metric_type: "latency",
+                    threshold: 2000,
+                    window_days: 7,
+                    status: "healthy",
+                    budget_remaining: 2.5,
+                    created_at: new Date(Date.now() - 86400000 * 7).toISOString(),
+                },
+                {
+                    id: "slo_errors",
+                    name: "Error Rate",
+                    description: "Error rate below 1%",
+                    target_percentage: 99,
+                    current_percentage: 98.2,
+                    metric_type: "error_rate",
+                    window_days: 7,
+                    status: "at_risk",
+                    budget_remaining: -0.8,
+                    created_at: new Date(Date.now() - 86400000 * 7).toISOString(),
+                },
+            ],
+            total: 3,
+        };
+        return { data: mockSLOs, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated setSLO
+    /**
+     * Create or update an SLO.
+     */
+    async setSLO(body: {
+        name: string;
+        description?: string;
+        target_percentage: number;
+        metric_type: SLO["metric_type"];
+        threshold?: number;
+        window_days: number;
+    }): Promise<APIResponse<SLO>> {
+        // MOCK - Returns simulated data
+        const mockSLO: SLO = {
+            id: `slo_${Date.now()}`,
+            name: body.name,
+            description: body.description,
+            target_percentage: body.target_percentage,
+            current_percentage: 100,
+            metric_type: body.metric_type,
+            threshold: body.threshold,
+            window_days: body.window_days,
+            status: "healthy",
+            budget_remaining: 100 - body.target_percentage,
+            created_at: new Date().toISOString(),
+        };
+        return { data: mockSLO, error: undefined, response: new Response() };
+    }
+
+    // ========== Postmortems ==========
+
+    // MOCK - Simulated createPostmortem
+    /**
+     * Create a postmortem for an incident.
+     */
+    async createPostmortem(incidentId: string, body: {
+        title: string;
+        summary: string;
+        root_cause_analysis: string;
+        impact: string;
+        lessons_learned: string[];
+        action_items: Omit<ActionItem, "id" | "status">[];
+    }): Promise<APIResponse<Postmortem>> {
+        // MOCK - Returns simulated data
+        const mockPostmortem: Postmortem = {
+            id: `pm_${Date.now()}`,
+            incident_id: incidentId,
+            title: body.title,
+            summary: body.summary,
+            timeline: [
+                { timestamp: new Date(Date.now() - 7200000).toISOString(), description: "Incident detected" },
+                { timestamp: new Date(Date.now() - 3600000).toISOString(), description: "Root cause identified" },
+                { timestamp: new Date().toISOString(), description: "Incident resolved" },
+            ],
+            root_cause_analysis: body.root_cause_analysis,
+            impact: body.impact,
+            action_items: body.action_items.map((item, i) => ({
+                ...item,
+                id: `action_${i}`,
+                status: "open" as const,
+            })),
+            lessons_learned: body.lessons_learned,
+            created_at: new Date().toISOString(),
+            created_by: "user_current",
+        };
+        return { data: mockPostmortem, error: undefined, response: new Response() };
+    }
+}

package/src/modules/members.ts

@@ -114,4 +114,15 @@ export class MembersModule {
             headers: this.headers(),
         });
     }
+
+    /**
+     * Ensure membership exists (auto-create on first access).
+     * This is used by the frontend for onboarding.
+     */
+    async ensure(tenantId?: string): Promise<APIResponse<Member>> {
+        return this.client.POST<Member>("/v1/api/memberships/ensure", {
+            body: { tenant_id: tenantId ?? null },
+            headers: this.headers(),
+        });
+    }
 }

package/src/modules/policies.ts

@@ -0,0 +1,258 @@
+/**
+ * Policies Module - Governance Rules
+ * 
+ * // MOCK - This module contains mock implementations for future features
+ * 
+ * Defines and evaluates policies that control agent behavior.
+ * Enables enterprise governance and compliance.
+ */
+
+import type { RawClient, APIResponse } from "../client/raw.js";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export type PolicyType = "allow" | "deny" | "require_approval" | "audit";
+export type PolicyScope = "tenant" | "workspace" | "agent" | "run";
+
+export interface Policy {
+    id: string;
+    name: string;
+    description?: string;
+    type: PolicyType;
+    scope: PolicyScope;
+    scope_id?: string;
+    conditions: PolicyCondition[];
+    actions: PolicyAction[];
+    priority: number;
+    enabled: boolean;
+    created_at: string;
+    updated_at: string;
+}
+
+export interface PolicyCondition {
+    field: string;
+    operator: "eq" | "neq" | "in" | "not_in" | "gt" | "lt" | "contains" | "regex";
+    value: unknown;
+}
+
+export interface PolicyAction {
+    type: "block" | "allow" | "require_approval" | "log" | "alert" | "modify";
+    config?: Record<string, unknown>;
+}
+
+export interface PolicyEvaluationInput {
+    action: string;
+    resource: string;
+    context: Record<string, unknown>;
+}
+
+export interface PolicyEvaluationResult {
+    allowed: boolean;
+    matched_policies: string[];
+    required_approvals: string[];
+    warnings: string[];
+    audit_entries: PolicyAuditEntry[];
+}
+
+export interface PolicyAuditEntry {
+    policy_id: string;
+    policy_name: string;
+    decision: "allow" | "deny" | "pending_approval";
+    reason: string;
+    evaluated_at: string;
+}
+
+export interface PolicyListResponse {
+    items: Policy[];
+    total: number;
+}
+
+// ============================================================================
+// Module
+// ============================================================================
+
+export class PoliciesModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) { }
+
+    // MOCK - Simulated list
+    /**
+     * List all policies.
+     */
+    async list(params?: {
+        scope?: PolicyScope;
+        enabled?: boolean;
+    }): Promise<APIResponse<PolicyListResponse>> {
+        // MOCK - Returns simulated data
+        const mockPolicies: PolicyListResponse = {
+            items: [
+                {
+                    id: "policy_1",
+                    name: "Block External Email",
+                    description: "Prevent agents from sending external emails without approval",
+                    type: "require_approval",
+                    scope: "tenant",
+                    conditions: [
+                        { field: "action", operator: "eq", value: "send_email" },
+                        { field: "recipient.domain", operator: "not_in", value: ["company.com"] },
+                    ],
+                    actions: [
+                        { type: "require_approval", config: { approver_role: "admin" } },
+                    ],
+                    priority: 100,
+                    enabled: true,
+                    created_at: new Date(Date.now() - 86400000).toISOString(),
+                    updated_at: new Date().toISOString(),
+                },
+                {
+                    id: "policy_2",
+                    name: "Audit All Tool Calls",
+                    description: "Log all tool calls for compliance",
+                    type: "audit",
+                    scope: "tenant",
+                    conditions: [
+                        { field: "action", operator: "eq", value: "tool_call" },
+                    ],
+                    actions: [
+                        { type: "log" },
+                    ],
+                    priority: 50,
+                    enabled: true,
+                    created_at: new Date(Date.now() - 86400000).toISOString(),
+                    updated_at: new Date().toISOString(),
+                },
+            ],
+            total: 2,
+        };
+        return { data: mockPolicies, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated get
+    /**
+     * Get a policy by ID.
+     */
+    async get(policyId: string): Promise<APIResponse<Policy>> {
+        // MOCK - Returns simulated data
+        const mockPolicy: Policy = {
+            id: policyId,
+            name: "Block External Email",
+            description: "Prevent agents from sending external emails without approval",
+            type: "require_approval",
+            scope: "tenant",
+            conditions: [
+                { field: "action", operator: "eq", value: "send_email" },
+            ],
+            actions: [
+                { type: "require_approval" },
+            ],
+            priority: 100,
+            enabled: true,
+            created_at: new Date(Date.now() - 86400000).toISOString(),
+            updated_at: new Date().toISOString(),
+        };
+        return { data: mockPolicy, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated create
+    /**
+     * Create a new policy.
+     */
+    async create(body: {
+        name: string;
+        description?: string;
+        type: PolicyType;
+        scope: PolicyScope;
+        scope_id?: string;
+        conditions: PolicyCondition[];
+        actions: PolicyAction[];
+        priority?: number;
+    }): Promise<APIResponse<Policy>> {
+        // MOCK - Returns simulated data
+        const mockPolicy: Policy = {
+            id: `policy_${Date.now()}`,
+            name: body.name,
+            description: body.description,
+            type: body.type,
+            scope: body.scope,
+            scope_id: body.scope_id,
+            conditions: body.conditions,
+            actions: body.actions,
+            priority: body.priority || 50,
+            enabled: true,
+            created_at: new Date().toISOString(),
+            updated_at: new Date().toISOString(),
+        };
+        return { data: mockPolicy, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated update
+    /**
+     * Update a policy.
+     */
+    async update(policyId: string, body: Partial<Policy>): Promise<APIResponse<Policy>> {
+        // MOCK - Returns simulated data
+        const mockPolicy: Policy = {
+            id: policyId,
+            name: body.name || "Updated Policy",
+            type: body.type || "allow",
+            scope: body.scope || "tenant",
+            conditions: body.conditions || [],
+            actions: body.actions || [],
+            priority: body.priority || 50,
+            enabled: body.enabled ?? true,
+            created_at: new Date(Date.now() - 86400000).toISOString(),
+            updated_at: new Date().toISOString(),
+        };
+        return { data: mockPolicy, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated delete
+    /**
+     * Delete a policy.
+     */
+    async delete(policyId: string): Promise<APIResponse<void>> {
+        // MOCK - Returns success
+        return { data: undefined, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated evaluate
+    /**
+     * Evaluate policies against an action (simulation).
+     */
+    async evaluate(input: PolicyEvaluationInput): Promise<APIResponse<PolicyEvaluationResult>> {
+        // MOCK - Returns simulated evaluation
+        const mockResult: PolicyEvaluationResult = {
+            allowed: true,
+            matched_policies: ["policy_2"],
+            required_approvals: [],
+            warnings: [],
+            audit_entries: [
+                {
+                    policy_id: "policy_2",
+                    policy_name: "Audit All Tool Calls",
+                    decision: "allow",
+                    reason: "Action logged for audit",
+                    evaluated_at: new Date().toISOString(),
+                },
+            ],
+        };
+        return { data: mockResult, error: undefined, response: new Response() };
+    }
+
+    // MOCK - Simulated enforce
+    /**
+     * Enforce policies (apply to current context).
+     */
+    async enforce(runId: string): Promise<APIResponse<PolicyEvaluationResult>> {
+        // MOCK - Returns simulated enforcement
+        const mockResult: PolicyEvaluationResult = {
+            allowed: true,
+            matched_policies: [],
+            required_approvals: [],
+            warnings: [],
+            audit_entries: [],
+        };
+        return { data: mockResult, error: undefined, response: new Response() };
+    }
+}

package/src/modules/tenants.ts

@@ -24,6 +24,15 @@ export interface TenantListResponse {
 export class TenantsModule {
     constructor(private client: RawClient, private headers: () => Record<string, string>) { }
 
+    /**
+     * List all tenants the user has access to.
+     */
+    async list(): Promise<APIResponse<Tenant[]>> {
+        return this.client.GET<Tenant[]>("/v1/api/tenants", {
+            headers: this.headers(),
+        });
+    }
+
     /**
      * Get the current tenant.
      */