@cadreen/sdk 0.1.0

package/README.md

@@ -0,0 +1,127 @@
+# @cadreen/sdk
+
+TypeScript SDK for Cadreen — Intelligence as a Service.
+
+## Install
+
+```bash
+npm install @cadreen/sdk
+```
+
+## Quick Start
+
+```ts
+import { Cadreen } from "@cadreen/sdk";
+
+const cadreen = new Cadreen({ apiKey: process.env.CADREEN_API_KEY });
+
+// Intent — the primary door
+const result = await cadreen.intent.invoke({
+  messages: [{ role: "user", content: "Handle refund for invoice inv_123" }],
+});
+
+switch (result.type) {
+  case "direct":
+    console.log(result.message.content);
+    break;
+  case "clarify":
+    for (const q of result.questions) console.log(q);
+    break;
+  case "execution":
+    for await (const event of cadreen.executions.stream(result.execution.id)) {
+      console.log(event.type, event.data);
+    }
+    break;
+  case "blocked":
+    console.log(result.policy.reason);
+    break;
+  case "connect_required":
+    console.log(result.connection.endpoint);
+    break;
+}
+
+// Memory — remember things
+await cadreen.memory.remember({
+  type: "reference",
+  content: { text: "GDPR Article 17...", title: "GDPR Art. 17" },
+  authority: 10,
+});
+
+// Policies — require approval
+await cadreen.policies.requireApproval("Refunds over $500 require human approval");
+
+// Traces — inspect what happened
+const trace = await cadreen.traces.get(result.traceId);
+console.log(trace.explain());
+
+// Connections — connect tools
+await cadreen.connections.registerOpenAPI({
+  name: "internal-erp",
+  specUrl: "https://erp.example.com/openapi.json",
+});
+```
+
+## Configuration
+
+```ts
+const cadreen = new Cadreen({
+  apiKey: "cadreen_...",                    // required
+  baseUrl: "https://accomplishanything.today", // optional, default shown
+  maxRetries: 2,                             // optional, default 2
+  timeout: 30000,                            // optional, default 30s
+  profile: "lean",                           // optional: "lean" | "audit" | "full" (default "full")
+});
+```
+
+### Response Profiles
+
+Control how much intelligence metadata you get back:
+
+| Profile | What you get | Use when |
+|---------|-------------|----------|
+| `"full"` (default) | Full intelligence envelope with capability, reasoning, memory, governance, humility, process | You want full transparency |
+| `"audit"` | Only governance decision + confidence + blocking gaps | You need to react to gates, not inspect internals |
+| `"lean"` | No envelope. `trace_id` in body + `X-Cadreen-Trace-ID` header | Hot-looping, minimal payload |
+
+```ts
+// Lean: skip the envelope entirely
+const lean = new Cadreen({ apiKey: "...", profile: "lean" });
+
+// Audit: just the action-bearing fields
+const audit = new Cadreen({ apiKey: "...", profile: "audit" });
+```
+
+## Error Handling
+
+```ts
+import { CadreenError } from "@cadreen/sdk";
+
+try {
+  const result = await cadreen.intent.invoke({ messages: [...] });
+} catch (err) {
+  if (err instanceof CadreenError) {
+    console.log(err.status);       // HTTP status
+    console.log(err.code);         // machine-readable code
+    console.log(err.intelligence); // trace context when available
+  }
+}
+```
+
+## Resources
+
+| Resource | Methods |
+|----------|---------|
+| `cadreen.intent` | `invoke(request)` |
+| `cadreen.memory` | `remember(request)`, `search(request)`, `get(id)` |
+| `cadreen.policies` | `create(request)`, `evaluate(request)`, `confirm(id)`, `list()`, `get(id)`, `requireApproval(desc)` |
+| `cadreen.connections` | `registerOpenAPI(request)`, `registerMCP(request)`, `installComposio(request)`, `searchComposio(query)`, `composioStatus(...)`, `list()`, `delete(id)` |
+| `cadreen.traces` | `get(id)`, `list(options?)`, `stats()` |
+| `cadreen.executions` | `stream(id)`, `getStatus(id)` |
+
+## Shorthand
+
+`cadreen.invoke(request)` is an alias for `cadreen.intent.invoke(request)`.
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,35 @@
+import type { CadreenConfig, RequestOptions } from "./types";
+export declare class CadreenError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly errorType: string;
+    readonly details?: Array<{
+        field: string;
+        message: string;
+    }>;
+    readonly intelligence?: unknown;
+    constructor(status: number, code: string, errorType: string, message: string, details?: Array<{
+        field: string;
+        message: string;
+    }>, intelligence?: unknown);
+}
+export declare class HttpClient {
+    private readonly baseUrl;
+    private readonly apiKey;
+    private readonly maxRetries;
+    private readonly timeout;
+    private readonly telemetry;
+    private readonly sandbox;
+    private readonly fixtures;
+    private readonly profile;
+    constructor(config: CadreenConfig);
+    private request;
+    get<T>(path: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    put<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
+    delete<T>(path: string): Promise<T>;
+    stream(path: string): AsyncGenerator<{
+        type: string;
+        data: Record<string, unknown>;
+    }>;
+}

package/dist/client.js

@@ -0,0 +1,205 @@
+import { NoOpProvider, wrapWithTelemetry } from "./telemetry";
+export class CadreenError extends Error {
+    constructor(status, code, errorType, message, details, intelligence) {
+        super(message);
+        this.name = "CadreenError";
+        this.status = status;
+        this.code = code;
+        this.errorType = errorType;
+        this.details = details;
+        this.intelligence = intelligence;
+    }
+}
+const DEFAULT_BASE_URL = "https://accomplishanything.today";
+const DEFAULT_MAX_RETRIES = 2;
+const DEFAULT_TIMEOUT = 30000;
+const RETRYABLE_STATUS_CODES = new Set([408, 429, 502, 503, 504]);
+const IDEMPOTENT_METHODS = new Set(["GET", "PUT"]);
+function generateIdempotencyKey() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+function buildQueryString(params) {
+    const parts = [];
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined && value !== "") {
+            parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+        }
+    }
+    return parts.length > 0 ? `?${parts.join("&")}` : "";
+}
+function parseSSELine(line) {
+    if (line.startsWith("event:")) {
+        return { event: line.slice(6).trim() };
+    }
+    if (line.startsWith("data:")) {
+        return { data: line.slice(5).trim() };
+    }
+    return {};
+}
+export class HttpClient {
+    constructor(config) {
+        this.baseUrl = (config.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, "");
+        this.apiKey = config.apiKey;
+        this.maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+        this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
+        this.sandbox = config.sandbox ?? false;
+        this.fixtures = config.fixtures ?? {};
+        this.profile = config.profile ?? "full";
+        const provider = config.telemetry ?? new NoOpProvider();
+        this.telemetry = wrapWithTelemetry(provider);
+    }
+    async request(method, path, body, options) {
+        if (this.sandbox) {
+            const fixtureKey = `${method} ${path}`;
+            if (fixtureKey in this.fixtures) {
+                return this.fixtures[fixtureKey];
+            }
+            if (path in this.fixtures) {
+                return this.fixtures[path];
+            }
+            throw new CadreenError(404, "not_found", "not_found", `No fixture for ${fixtureKey}. Provide fixtures via CadreenConfig.fixtures keyed by "METHOD /path" or "/path".`);
+        }
+        const url = `${this.baseUrl}${path}`;
+        const span = this.telemetry.onRequestStart(method, path);
+        const startTime = Date.now();
+        const headers = {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: `application/json; profile="${this.profile}"`,
+            ...(options?.headers || {}),
+        };
+        if (method === "POST" || method === "PUT" || method === "PATCH") {
+            headers["Idempotency-Key"] = options?.idempotencyKey || generateIdempotencyKey();
+        }
+        const isIdempotent = IDEMPOTENT_METHODS.has(method) || !!headers["Idempotency-Key"];
+        const maxAttempts = isIdempotent ? this.maxRetries + 1 : 1;
+        let lastError = null;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            if (attempt > 0) {
+                const delay = Math.min(1000 * Math.pow(2, attempt - 1), 10000);
+                this.telemetry.onRetry(method, path, attempt);
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+            try {
+                const controller = new AbortController();
+                const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+                const response = await fetch(url, {
+                    method,
+                    headers,
+                    body: body !== undefined ? JSON.stringify(body) : undefined,
+                    signal: controller.signal,
+                });
+                clearTimeout(timeoutId);
+                if (!response.ok) {
+                    let errorBody = null;
+                    try {
+                        errorBody = await response.json();
+                    }
+                    catch {
+                        // not JSON
+                    }
+                    const err = new CadreenError(response.status, errorBody?.error?.code || "unknown", errorBody?.error?.type || "error", errorBody?.error?.message || response.statusText, errorBody?.error?.details, errorBody?.intelligence);
+                    if (RETRYABLE_STATUS_CODES.has(response.status) && isIdempotent && attempt < maxAttempts - 1) {
+                        lastError = err;
+                        continue;
+                    }
+                    this.telemetry.onError(span, err);
+                    throw err;
+                }
+                if (response.status === 204) {
+                    this.telemetry.onRequestEnd(span, method, path, 204, Date.now() - startTime);
+                    return undefined;
+                }
+                const result = (await response.json());
+                this.telemetry.onRequestEnd(span, method, path, response.status, Date.now() - startTime);
+                return result;
+            }
+            catch (error) {
+                if (error instanceof CadreenError) {
+                    throw error;
+                }
+                if (error instanceof DOMException && error.name === "AbortError") {
+                    throw new CadreenError(408, "timeout", "timeout", "Request timed out");
+                }
+                if (isIdempotent && attempt < maxAttempts - 1) {
+                    lastError = new CadreenError(0, "network_error", "network", error.message);
+                    continue;
+                }
+                throw new CadreenError(0, "network_error", "network", error.message);
+            }
+        }
+        throw lastError || new CadreenError(0, "network_error", "network", "Request failed after retries");
+    }
+    async get(path, params) {
+        const qs = params ? buildQueryString(params) : "";
+        return this.request("GET", `${path}${qs}`);
+    }
+    async post(path, body, options) {
+        return this.request("POST", path, body, options);
+    }
+    async put(path, body, options) {
+        return this.request("PUT", path, body, options);
+    }
+    async delete(path) {
+        return this.request("DELETE", path);
+    }
+    async *stream(path) {
+        const url = `${this.baseUrl}${path}`;
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+            Accept: "text/event-stream",
+        };
+        const response = await fetch(url, {
+            method: "GET",
+            headers,
+        });
+        if (!response.ok) {
+            let errorBody = null;
+            try {
+                errorBody = await response.json();
+            }
+            catch {
+                // not JSON
+            }
+            throw new CadreenError(response.status, errorBody?.error?.code || "unknown", errorBody?.error?.type || "error", errorBody?.error?.message || response.statusText, errorBody?.error?.details, errorBody?.intelligence);
+        }
+        const reader = response.body?.getReader();
+        if (!reader) {
+            throw new CadreenError(0, "stream_error", "network", "Response body is not readable");
+        }
+        const decoder = new TextDecoder();
+        let buffer = "";
+        let currentEvent = "message";
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+                const parsed = parseSSELine(line);
+                if (parsed.event) {
+                    currentEvent = parsed.event;
+                }
+                if (parsed.data) {
+                    try {
+                        const data = JSON.parse(parsed.data);
+                        yield { type: currentEvent, data };
+                    }
+                    catch {
+                        yield { type: currentEvent, data: { raw: parsed.data } };
+                    }
+                    currentEvent = "message";
+                }
+            }
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { IntentResource } from "./resources/intent";
+import { MemoryResource } from "./resources/memory";
+import { PoliciesResource } from "./resources/policies";
+import { ConnectionsResource } from "./resources/connections";
+import { TracesResource } from "./resources/traces";
+import { ExecutionsResource } from "./resources/executions";
+import { GuardrailsResource } from "./resources/guardrails";
+import { SkillsResource } from "./resources/skills";
+import { FailuresResource } from "./resources/failures";
+import type { CadreenConfig, IntentRequest, IntentResult, IntentContext, RememberRequest, CreateMemoryResponse, SearchMemoryRequest, SearchMemoryResponse, ConnectResult, SetupRequest, SetupResult } from "./types";
+export { CadreenError } from "./client";
+export { requiresHuman, handoffReason, explainTrace, redactTrace, redactMessages, redactResult } from "./intelligence_helpers";
+export { intentStatus } from "./types";
+export type { RedactOptions } from "./intelligence_helpers";
+export type { TelemetryProvider, TelemetrySpan, TelemetryMeter } from "./telemetry";
+export { OpenTelemetryAdapter, NoOpProvider, NoOpSpan, NoOpMeter } from "./telemetry";
+export declare class Cadreen {
+    readonly intent: IntentResource;
+    readonly memory: MemoryResource;
+    readonly policies: PoliciesResource;
+    readonly connections: ConnectionsResource;
+    readonly traces: TracesResource;
+    readonly executions: ExecutionsResource;
+    readonly guardrails: GuardrailsResource;
+    readonly skills: SkillsResource;
+    readonly failures: FailuresResource;
+    private readonly client;
+    constructor(config: CadreenConfig);
+    invoke(request: IntentRequest): Promise<IntentResult>;
+    ask(prompt: string, options?: {
+        conversation_id?: string;
+        context?: IntentContext;
+        stream?: boolean;
+    }): Promise<IntentResult>;
+    act(prompt: string, options?: {
+        conversation_id?: string;
+        context?: IntentContext;
+        stream?: boolean;
+    }): Promise<IntentResult>;
+    remember(request: RememberRequest): Promise<CreateMemoryResponse>;
+    context(request: SearchMemoryRequest): Promise<SearchMemoryResponse>;
+    connect(capability: string): Promise<ConnectResult>;
+    setup(request: SetupRequest): Promise<SetupResult>;
+}
+export type { CadreenConfig, HealthStatus, ConnectorType, CapabilitySource, TransportType, EscalationStatus, CredentialType, AtomScope, AtomType, ErrorCategory, RecoveryStrategyType, StackItemSource, StackItemStatus, GovernanceDecisionType, RecoveryStatus, IntentMode, Pagination, Pathway, ConnectionGroup, ListConnectionsResponse, AtomContent, Atom, CreateMemoryResponse, SearchMemoryResponse, Policy, PolicyBundle, GovernanceDecision, EvaluatePolicyResponse, CreatePolicyResponse, ConfirmPolicyResponse, Escalation, ListEscalationsResponse, CredentialMetadata, ListCredentialsResponse, CapabilityMatch, ListCapabilitiesResponse, ListPoliciesResponse, Gap, Outcome, Assessment, PolicyRecommendation, StackItem, StackBreakdown, CapabilityTrace, ReasoningTrace, MemoryTrace, GovernanceTrace, HumilityTrace, ProcessTrace, IntelligenceMeta, IntelligenceTraceEntry, ListIntelligenceResponse, IntelligenceStats, IntentMessage, IntentContext, IntentRequest, ResponseMessage, ResponseExecution, IntentResult, IntentStatus, RegisterOpenAPIRequest, RegisterOpenAPIResponse, RegisterMCPRequest, RegisterMCPResponse, InstallComposioRequest, SearchMemoryRequest, RememberRequest, CreatePolicyRequest, EvaluatePolicyRequest, ExecutionEvent, ExecutionStatus, TraceExplain, RequestOptions, NextAction, IntelligenceStage, FieldStability, ClarificationQuestion, ConnectResult, ConnectResultType, ConnectPrebuiltDetail, ConnectSchemaRequiredDetail, ConnectManualDetail, ConnectPathway, ConnectUnknownDetail, SetupRequest, SetupResult, SetupConnectionResult, SetupCredentialResult, SetupMemoryResult, SetupPolicyResult, } from "./types";
+export { GuardrailsResource } from "./resources/guardrails";

package/dist/index.js

@@ -0,0 +1,62 @@
+import { HttpClient } from "./client";
+import { IntentResource } from "./resources/intent";
+import { MemoryResource } from "./resources/memory";
+import { PoliciesResource } from "./resources/policies";
+import { ConnectionsResource } from "./resources/connections";
+import { TracesResource } from "./resources/traces";
+import { ExecutionsResource } from "./resources/executions";
+import { GuardrailsResource } from "./resources/guardrails";
+import { SkillsResource } from "./resources/skills";
+import { FailuresResource } from "./resources/failures";
+export { CadreenError } from "./client";
+export { requiresHuman, handoffReason, explainTrace, redactTrace, redactMessages, redactResult } from "./intelligence_helpers";
+export { intentStatus } from "./types";
+export { OpenTelemetryAdapter, NoOpProvider, NoOpSpan, NoOpMeter } from "./telemetry";
+export class Cadreen {
+    constructor(config) {
+        this.client = new HttpClient(config);
+        this.intent = new IntentResource(this.client);
+        this.memory = new MemoryResource(this.client);
+        this.policies = new PoliciesResource(this.client);
+        this.connections = new ConnectionsResource(this.client);
+        this.traces = new TracesResource(this.client);
+        this.executions = new ExecutionsResource(this.client);
+        this.guardrails = new GuardrailsResource(this.policies);
+        this.skills = new SkillsResource(this.intent, this.memory, this.connections);
+        this.failures = new FailuresResource(this.traces);
+    }
+    async invoke(request) {
+        return this.intent.invoke(request);
+    }
+    async ask(prompt, options) {
+        return this.intent.invoke({
+            messages: [{ role: "user", content: prompt }],
+            mode: "chat",
+            conversation_id: options?.conversation_id,
+            context: options?.context,
+            stream: options?.stream,
+        });
+    }
+    async act(prompt, options) {
+        return this.intent.invoke({
+            messages: [{ role: "user", content: prompt }],
+            mode: "execution",
+            conversation_id: options?.conversation_id,
+            context: options?.context,
+            stream: options?.stream,
+        });
+    }
+    async remember(request) {
+        return this.memory.remember(request);
+    }
+    async context(request) {
+        return this.memory.search(request);
+    }
+    async connect(capability) {
+        return this.connections.connect(capability);
+    }
+    async setup(request) {
+        return this.client.post("/api/v1/cadreen/setup", request);
+    }
+}
+export { GuardrailsResource } from "./resources/guardrails";

package/dist/intelligence_helpers.d.ts

@@ -0,0 +1,11 @@
+import type { IntelligenceMeta, IntentResult, IntentMessage } from "./types";
+export declare function requiresHuman(intel: IntelligenceMeta): boolean;
+export declare function handoffReason(intel: IntelligenceMeta): string | null;
+export declare function explainTrace(intel: IntelligenceMeta): string;
+export interface RedactOptions {
+    preserveUUIDs?: boolean;
+    keysToRedact?: string[];
+}
+export declare function redactTrace(intel: IntelligenceMeta, options?: RedactOptions): IntelligenceMeta;
+export declare function redactMessages(messages: IntentMessage[], options?: RedactOptions): IntentMessage[];
+export declare function redactResult(result: IntentResult, options?: RedactOptions): IntentResult;

package/dist/intelligence_helpers.js

@@ -0,0 +1,107 @@
+export function requiresHuman(intel) {
+    if (intel.governance.decision === "blocked" && (intel.humility.blocking ?? 0) > 0) {
+        return true;
+    }
+    if (intel.stages) {
+        for (const stage of intel.stages) {
+            if ((stage.name === "escalation" || stage.name === "human_handoff") && stage.status !== "skipped") {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function handoffReason(intel) {
+    if (intel.stages) {
+        for (const stage of intel.stages) {
+            if ((stage.name === "escalation" || stage.name === "human_handoff") && stage.status !== "skipped") {
+                return stage.detail ?? null;
+            }
+        }
+    }
+    if (intel.next_action?.reason) {
+        return intel.next_action.reason;
+    }
+    return null;
+}
+export function explainTrace(intel) {
+    const parts = [];
+    if (intel.summary) {
+        parts.push(intel.summary);
+    }
+    if (intel.stages && intel.stages.length > 0) {
+        const stageParts = intel.stages.map((s) => {
+            let line = `${s.name}: ${s.status}`;
+            if (s.detail) {
+                line += ` — ${s.detail}`;
+            }
+            return line;
+        });
+        parts.push(stageParts.join("; "));
+    }
+    if (requiresHuman(intel)) {
+        parts.push("Requires human intervention");
+    }
+    return parts.length > 0 ? parts.join("\n") : "No intelligence trace available";
+}
+const EMAIL_RE = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
+const PHONE_RE = /(?:\+?\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}/g;
+const UUID_RE = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
+const API_KEY_RE = /sk_[a-zA-Z]+_[a-zA-Z0-9]{8,}/g;
+const IP_RE = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g;
+function redactString(text, options) {
+    let result = text;
+    result = result.replace(EMAIL_RE, "[email]");
+    result = result.replace(PHONE_RE, "[phone]");
+    result = result.replace(API_KEY_RE, "[api_key]");
+    result = result.replace(IP_RE, "[ip]");
+    if (!options?.preserveUUIDs) {
+        result = result.replace(UUID_RE, "[id]");
+    }
+    return result;
+}
+function redactValue(value, options) {
+    if (typeof value === "string") {
+        return redactString(value, options);
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => redactValue(v, options));
+    }
+    if (value && typeof value === "object") {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            if (key === "__proto__" || key === "constructor" || key === "prototype") {
+                continue;
+            }
+            const keysToRedact = options?.keysToRedact ?? ["content", "message", "text", "body", "email", "phone", "address", "name"];
+            if (keysToRedact.includes(key.toLowerCase()) && typeof val === "string") {
+                result[key] = redactString(val, options);
+            }
+            else {
+                result[key] = redactValue(val, options);
+            }
+        }
+        return result;
+    }
+    return value;
+}
+export function redactTrace(intel, options) {
+    return redactValue(intel, options);
+}
+export function redactMessages(messages, options) {
+    return messages.map((msg) => ({
+        role: msg.role,
+        content: redactString(msg.content, options),
+    }));
+}
+export function redactResult(result, options) {
+    const redacted = { ...result };
+    if ("intelligence" in redacted && redacted.intelligence) {
+        redacted.intelligence = redactTrace(redacted.intelligence, options);
+    }
+    if ("message" in redacted && redacted.message && typeof redacted.message === "object" && "content" in redacted.message) {
+        const msg = redacted.message;
+        redacted.message = { ...msg, content: redactString(msg.content, options) };
+    }
+    return redacted;
+}

package/dist/resources/connections.d.ts

@@ -0,0 +1,14 @@
+import type { RegisterOpenAPIRequest, RegisterOpenAPIResponse, RegisterMCPRequest, RegisterMCPResponse, ListConnectionsResponse, InstallComposioRequest, ConnectResult } from "../types";
+import { HttpClient } from "../client";
+export declare class ConnectionsResource {
+    private client;
+    constructor(client: HttpClient);
+    connect(capability: string): Promise<ConnectResult>;
+    registerOpenAPI(request: RegisterOpenAPIRequest): Promise<RegisterOpenAPIResponse>;
+    registerMCP(request: RegisterMCPRequest): Promise<RegisterMCPResponse>;
+    installComposio(request: InstallComposioRequest): Promise<Record<string, unknown>>;
+    searchComposio(query: string): Promise<Record<string, unknown>>;
+    composioStatus(toolkit?: string, userId?: string): Promise<Record<string, unknown>>;
+    list(): Promise<ListConnectionsResponse>;
+    delete(id: string): Promise<void>;
+}

package/dist/resources/connections.js

@@ -0,0 +1,37 @@
+export class ConnectionsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async connect(capability) {
+        return this.client.post("/api/v1/cadreen/connections", { capability });
+    }
+    async registerOpenAPI(request) {
+        return this.client.post("/api/v1/cadreen/connections/openapi", request);
+    }
+    async registerMCP(request) {
+        return this.client.post("/api/v1/cadreen/connections/mcp", request);
+    }
+    async installComposio(request) {
+        return this.client.post("/api/v1/cadreen/connections/composio/install", {
+            toolkit: request.toolkit,
+            user_id: request.user_id,
+        });
+    }
+    async searchComposio(query) {
+        return this.client.post("/api/v1/cadreen/connections/composio/search", { query });
+    }
+    async composioStatus(toolkit, userId) {
+        const params = {};
+        if (toolkit)
+            params.toolkit = toolkit;
+        if (userId)
+            params.user_id = userId;
+        return this.client.get("/api/v1/cadreen/connections/composio/status", params);
+    }
+    async list() {
+        return this.client.get("/api/v1/cadreen/connections");
+    }
+    async delete(id) {
+        return this.client.delete(`/api/v1/cadreen/connections/${encodeURIComponent(id)}`);
+    }
+}

package/dist/resources/executions.d.ts

@@ -0,0 +1,8 @@
+import type { ExecutionEvent, ExecutionStatus } from "../types";
+import { HttpClient } from "../client";
+export declare class ExecutionsResource {
+    private client;
+    constructor(client: HttpClient);
+    stream(executionId: string): AsyncGenerator<ExecutionEvent>;
+    getStatus(executionId: string): Promise<ExecutionStatus>;
+}

package/dist/resources/executions.js

@@ -0,0 +1,17 @@
+export class ExecutionsResource {
+    constructor(client) {
+        this.client = client;
+    }
+    async *stream(executionId) {
+        const path = `/api/v1/cadreen/executions/${encodeURIComponent(executionId)}/stream`;
+        for await (const event of this.client.stream(path)) {
+            yield {
+                type: event.type,
+                data: event.data,
+            };
+        }
+    }
+    async getStatus(executionId) {
+        return this.client.get(`/api/v1/cadreen/executions/${encodeURIComponent(executionId)}`);
+    }
+}