quantum-ai-sdk 0.4.0 → 0.6.0

package/dist/missions.js

@@ -0,0 +1,278 @@
+// ── Wire format helpers ──────────────────────────────────────────
+/** @internal */
+function createReqToWire(req) {
+    const out = { goal: req.goal };
+    if (req.strategy !== undefined)
+        out.strategy = req.strategy;
+    if (req.conductorModel !== undefined)
+        out.conductor_model = req.conductorModel;
+    if (req.workers !== undefined)
+        out.workers = req.workers;
+    if (req.maxSteps !== undefined)
+        out.max_steps = req.maxSteps;
+    if (req.systemPrompt !== undefined)
+        out.system_prompt = req.systemPrompt;
+    if (req.sessionId !== undefined)
+        out.session_id = req.sessionId;
+    return out;
+}
+/** @internal */
+function chatReqToWire(req) {
+    const out = { message: req.message };
+    if (req.stream !== undefined)
+        out.stream = req.stream;
+    return out;
+}
+/** @internal */
+function planUpdateToWire(req) {
+    const out = {};
+    if (req.tasks !== undefined)
+        out.tasks = req.tasks;
+    if (req.workers !== undefined)
+        out.workers = req.workers;
+    if (req.systemPrompt !== undefined)
+        out.system_prompt = req.systemPrompt;
+    if (req.maxSteps !== undefined)
+        out.max_steps = req.maxSteps;
+    if (req.context !== undefined)
+        out.context = req.context;
+    return out;
+}
+/** @internal */
+function approveReqToWire(req) {
+    const out = {};
+    if (req.commitSha !== undefined)
+        out.commit_sha = req.commitSha;
+    if (req.comment !== undefined)
+        out.comment = req.comment;
+    return out;
+}
+/** @internal */
+function importReqToWire(req) {
+    const out = { goal: req.goal, tasks: req.tasks };
+    if (req.strategy !== undefined)
+        out.strategy = req.strategy;
+    if (req.conductorModel !== undefined)
+        out.conductor_model = req.conductorModel;
+    if (req.workers !== undefined)
+        out.workers = req.workers;
+    if (req.systemPrompt !== undefined)
+        out.system_prompt = req.systemPrompt;
+    if (req.maxSteps !== undefined)
+        out.max_steps = req.maxSteps;
+    if (req.autoExecute !== undefined)
+        out.auto_execute = req.autoExecute;
+    return out;
+}
+/** @internal */
+function taskFromWire(raw) {
+    return {
+        id: raw.id,
+        name: raw.name,
+        description: raw.description,
+        worker: raw.worker,
+        model: raw.model,
+        status: raw.status,
+        result: raw.result,
+        error: raw.error,
+        step: raw.step ?? 0,
+        tokensIn: raw.tokens_in ?? 0,
+        tokensOut: raw.tokens_out ?? 0,
+    };
+}
+/** @internal */
+function detailFromWire(raw) {
+    const tasks = (raw.tasks ?? []).map(taskFromWire);
+    return {
+        id: raw.id,
+        userId: raw.user_id,
+        goal: raw.goal,
+        strategy: raw.strategy,
+        conductorModel: raw.conductor_model,
+        status: raw.status,
+        createdAt: raw.created_at,
+        startedAt: raw.started_at,
+        completedAt: raw.completed_at,
+        error: raw.error,
+        costTicks: raw.cost_ticks ?? 0,
+        totalSteps: raw.total_steps ?? 0,
+        sessionId: raw.session_id,
+        result: raw.result,
+        tasks,
+        approved: raw.approved ?? false,
+        commitSha: raw.commit_sha,
+    };
+}
+/** @internal */
+function createRespFromWire(raw) {
+    return {
+        missionId: raw.mission_id ?? "",
+        status: raw.status ?? "",
+        sessionId: raw.session_id,
+        conductorModel: raw.conductor_model,
+        strategy: raw.strategy,
+        workers: raw.workers,
+        createdAt: raw.created_at,
+        requestId: raw.request_id,
+    };
+}
+/** @internal */
+function chatRespFromWire(raw) {
+    let usage;
+    if (raw.usage) {
+        const u = raw.usage;
+        usage = {
+            inputTokens: u.input_tokens ?? 0,
+            outputTokens: u.output_tokens ?? 0,
+        };
+    }
+    return {
+        missionId: raw.mission_id,
+        content: raw.content,
+        model: raw.model,
+        costTicks: raw.cost_ticks ?? 0,
+        usage,
+    };
+}
+/** @internal */
+function statusRespFromWire(raw) {
+    return {
+        missionId: raw.mission_id,
+        status: raw.status,
+        confirmed: raw.confirmed,
+        approved: raw.approved,
+        deleted: raw.deleted,
+        updated: raw.updated,
+        commitSha: raw.commit_sha,
+    };
+}
+/** @internal */
+function checkpointFromWire(raw) {
+    return {
+        id: raw.id,
+        commitSha: raw.commit_sha,
+        message: raw.message,
+        createdAt: raw.created_at,
+    };
+}
+// ── Client methods ───────────────────────────────────────────────
+/**
+ * Create and execute a mission asynchronously.
+ * @internal
+ */
+export async function missionCreate(client, req) {
+    const { data } = await client._doJSON("POST", "/qai/v1/missions/create", createReqToWire(req));
+    return createRespFromWire(data);
+}
+/**
+ * List missions for the authenticated user.
+ * @internal
+ */
+export async function missionList(client, status) {
+    const path = status
+        ? `/qai/v1/missions/list?status=${encodeURIComponent(status)}`
+        : "/qai/v1/missions/list";
+    const { data } = await client._doJSON("GET", path, undefined);
+    const missions = (data.missions ?? []).map(detailFromWire);
+    return { missions };
+}
+/**
+ * Get mission details including tasks.
+ * @internal
+ */
+export async function missionGet(client, missionId) {
+    const { data } = await client._doJSON("GET", `/qai/v1/missions/${encodeURIComponent(missionId)}`, undefined);
+    return detailFromWire(data);
+}
+/**
+ * Delete a mission.
+ * @internal
+ */
+export async function missionDelete(client, missionId) {
+    const { data } = await client._doJSON("DELETE", `/qai/v1/missions/${encodeURIComponent(missionId)}`, undefined);
+    return statusRespFromWire(data);
+}
+/**
+ * Cancel a running mission.
+ * @internal
+ */
+export async function missionCancel(client, missionId) {
+    const { data } = await client._doJSON("POST", `/qai/v1/missions/${encodeURIComponent(missionId)}/cancel`, undefined);
+    return statusRespFromWire(data);
+}
+/**
+ * Pause a running mission.
+ * @internal
+ */
+export async function missionPause(client, missionId) {
+    const { data } = await client._doJSON("POST", `/qai/v1/missions/${encodeURIComponent(missionId)}/pause`, undefined);
+    return statusRespFromWire(data);
+}
+/**
+ * Resume a paused mission.
+ * @internal
+ */
+export async function missionResume(client, missionId) {
+    const { data } = await client._doJSON("POST", `/qai/v1/missions/${encodeURIComponent(missionId)}/resume`, undefined);
+    return statusRespFromWire(data);
+}
+/**
+ * Chat with the mission's architect.
+ * @internal
+ */
+export async function missionChat(client, missionId, req) {
+    const { data } = await client._doJSON("POST", `/qai/v1/missions/${encodeURIComponent(missionId)}/chat`, chatReqToWire(req));
+    return chatRespFromWire(data);
+}
+/**
+ * Retry a failed task.
+ * @internal
+ */
+export async function missionRetryTask(client, missionId, taskId) {
+    const { data } = await client._doJSON("POST", `/qai/v1/missions/${encodeURIComponent(missionId)}/retry/${encodeURIComponent(taskId)}`, undefined);
+    return statusRespFromWire(data);
+}
+/**
+ * Approve a completed mission.
+ * @internal
+ */
+export async function missionApprove(client, missionId, req) {
+    const { data } = await client._doJSON("POST", `/qai/v1/missions/${encodeURIComponent(missionId)}/approve`, approveReqToWire(req));
+    return statusRespFromWire(data);
+}
+/**
+ * Update the mission plan.
+ * @internal
+ */
+export async function missionUpdatePlan(client, missionId, req) {
+    const { data } = await client._doJSON("PUT", `/qai/v1/missions/${encodeURIComponent(missionId)}/plan`, planUpdateToWire(req));
+    return statusRespFromWire(data);
+}
+/**
+ * Confirm or reject the proposed execution structure.
+ * @internal
+ */
+export async function missionConfirmStructure(client, missionId, req) {
+    const { data } = await client._doJSON("POST", `/qai/v1/missions/${encodeURIComponent(missionId)}/confirm-structure`, req);
+    return statusRespFromWire(data);
+}
+/**
+ * List git checkpoints for a mission.
+ * @internal
+ */
+export async function missionCheckpoints(client, missionId) {
+    const { data } = await client._doJSON("GET", `/qai/v1/missions/${encodeURIComponent(missionId)}/checkpoints`, undefined);
+    const checkpoints = (data.checkpoints ?? []).map(checkpointFromWire);
+    return {
+        missionId: data.mission_id,
+        checkpoints,
+    };
+}
+/**
+ * Import an existing plan as a new mission.
+ * @internal
+ */
+export async function missionImport(client, req) {
+    const { data } = await client._doJSON("POST", "/qai/v1/missions/import", importReqToWire(req));
+    return createRespFromWire(data);
+}

package/dist/security.d.ts

@@ -0,0 +1,158 @@
+import type { QuantumClient } from "./client.js";
+/** Request body for scanning a URL for prompt injection. */
+export interface SecurityScanUrlRequest {
+    /** URL to scan. */
+    url: string;
+}
+/** Request body for scanning raw HTML content. */
+export interface SecurityScanHtmlRequest {
+    /** Raw HTML to scan. */
+    html: string;
+    /** Rendered visible text (for structural analysis). */
+    visibleText?: string;
+    /** Source URL (for context). */
+    url?: string;
+}
+/** Request body for reporting a suspicious URL. */
+export interface SecurityReportRequest {
+    /** URL to report. */
+    url: string;
+    /** Description of the suspected threat. */
+    description?: string;
+    /** Category of the suspected threat. */
+    category?: string;
+}
+/** A single detected injection pattern. */
+export interface SecurityFinding {
+    /** Category: "instruction_override", "role_impersonation", "data_exfiltration", etc. */
+    category: string;
+    /** Pattern that matched. */
+    pattern: string;
+    /** Offending content (truncated). */
+    content: string;
+    /** Location in the page. */
+    location: string;
+    /** Threat level for this finding. */
+    threat: string;
+    /** Detection confidence (0.0 - 1.0). */
+    confidence: number;
+    /** Human-readable description. */
+    description: string;
+}
+/** Threat assessment for a scanned page. */
+export interface SecurityAssessment {
+    /** Source URL. */
+    url: string;
+    /** Overall threat level: "none", "low", "medium", "high", "critical". */
+    threatLevel: string;
+    /** Numeric threat score (0.0 - 100.0). */
+    threatScore: number;
+    /** Individual findings. */
+    findings: SecurityFinding[];
+    /** Length of hidden text content detected. */
+    hiddenTextLength: number;
+    /** Length of visible text content. */
+    visibleTextLength: number;
+    /** Ratio of hidden to total content. */
+    hiddenRatio: number;
+    /** Human-readable summary. */
+    summary: string;
+}
+/** Response from a security scan. */
+export interface SecurityScanResponse {
+    /** Full threat assessment. */
+    assessment: SecurityAssessment;
+    /** Request identifier. */
+    requestId: string;
+}
+/** Response from checking a URL against the registry. */
+export interface SecurityCheckResponse {
+    /** URL that was checked. */
+    url: string;
+    /** Whether the URL is blocked. */
+    blocked: boolean;
+    /** Threat level (if blocked). */
+    threatLevel?: string;
+    /** Threat score (if blocked). */
+    threatScore?: number;
+    /** Detection categories (if blocked). */
+    categories?: string[];
+    /** First seen timestamp. */
+    firstSeen?: string;
+    /** Last seen timestamp. */
+    lastSeen?: string;
+    /** Number of reports. */
+    reportCount?: number;
+    /** Registry status: "confirmed", "suspected". */
+    status?: string;
+    /** Human-readable message. */
+    message?: string;
+}
+/** A single blocklist entry. */
+export interface SecurityBlocklistEntry {
+    /** Entry identifier. */
+    id?: string;
+    /** Blocked URL. */
+    url: string;
+    /** Registry status. */
+    status: string;
+    /** Threat level. */
+    threatLevel: string;
+    /** Threat score. */
+    threatScore: number;
+    /** Detection categories. */
+    categories: string[];
+    /** Number of findings. */
+    findingsCount: number;
+    /** Hidden content ratio. */
+    hiddenRatio: number;
+    /** First seen timestamp. */
+    firstSeen?: string;
+    /** Summary. */
+    summary: string;
+}
+/** Response from the blocklist feed. */
+export interface SecurityBlocklistResponse {
+    /** Blocklist entries. */
+    entries: SecurityBlocklistEntry[];
+    /** Total count. */
+    count: number;
+    /** Filter status used. */
+    status: string;
+}
+/** Response from reporting a URL. */
+export interface SecurityReportResponse {
+    /** URL that was reported. */
+    url: string;
+    /** Report status: "existing" or "suspected". */
+    status: string;
+    /** Message. */
+    message: string;
+    /** Threat level (if already in registry). */
+    threatLevel?: string;
+}
+/**
+ * Scan a URL for prompt injection attacks.
+ * @internal
+ */
+export declare function securityScanUrl(client: QuantumClient, url: string): Promise<SecurityScanResponse>;
+/**
+ * Scan raw HTML content for prompt injection.
+ * @internal
+ */
+export declare function securityScanHtml(client: QuantumClient, req: SecurityScanHtmlRequest): Promise<SecurityScanResponse>;
+/**
+ * Check a URL against the injection registry.
+ * @internal
+ */
+export declare function securityCheck(client: QuantumClient, url: string): Promise<SecurityCheckResponse>;
+/**
+ * Get the injection blocklist feed.
+ * @internal
+ */
+export declare function securityBlocklist(client: QuantumClient, status?: string): Promise<SecurityBlocklistResponse>;
+/**
+ * Report a suspicious URL.
+ * @internal
+ */
+export declare function securityReport(client: QuantumClient, req: SecurityReportRequest): Promise<SecurityReportResponse>;

package/dist/security.js

@@ -0,0 +1,135 @@
+// ── Wire format helpers ──────────────────────────────────────────
+/** @internal */
+function scanHtmlToWire(req) {
+    const out = { html: req.html };
+    if (req.visibleText !== undefined)
+        out.visible_text = req.visibleText;
+    if (req.url !== undefined)
+        out.url = req.url;
+    return out;
+}
+/** @internal */
+function findingFromWire(raw) {
+    return {
+        category: raw.category ?? "",
+        pattern: raw.pattern ?? "",
+        content: raw.content ?? "",
+        location: raw.location ?? "",
+        threat: raw.threat ?? "",
+        confidence: raw.confidence ?? 0,
+        description: raw.description ?? "",
+    };
+}
+/** @internal */
+function assessmentFromWire(raw) {
+    const findings = (raw.findings ?? []).map(findingFromWire);
+    return {
+        url: raw.url ?? "",
+        threatLevel: raw.threat_level ?? "",
+        threatScore: raw.threat_score ?? 0,
+        findings,
+        hiddenTextLength: raw.hidden_text_length ?? 0,
+        visibleTextLength: raw.visible_text_length ?? 0,
+        hiddenRatio: raw.hidden_ratio ?? 0,
+        summary: raw.summary ?? "",
+    };
+}
+/** @internal */
+function scanRespFromWire(raw) {
+    return {
+        assessment: assessmentFromWire(raw.assessment ?? {}),
+        requestId: raw.request_id ?? "",
+    };
+}
+/** @internal */
+function checkRespFromWire(raw) {
+    return {
+        url: raw.url ?? "",
+        blocked: raw.blocked ?? false,
+        threatLevel: raw.threat_level,
+        threatScore: raw.threat_score,
+        categories: raw.categories,
+        firstSeen: raw.first_seen,
+        lastSeen: raw.last_seen,
+        reportCount: raw.report_count,
+        status: raw.status,
+        message: raw.message,
+    };
+}
+/** @internal */
+function blocklistEntryFromWire(raw) {
+    return {
+        id: raw.id,
+        url: raw.url ?? "",
+        status: raw.status ?? "",
+        threatLevel: raw.threat_level ?? "",
+        threatScore: raw.threat_score ?? 0,
+        categories: raw.categories ?? [],
+        findingsCount: raw.findings_count ?? 0,
+        hiddenRatio: raw.hidden_ratio ?? 0,
+        firstSeen: raw.first_seen,
+        summary: raw.summary ?? "",
+    };
+}
+/** @internal */
+function blocklistRespFromWire(raw) {
+    const entries = (raw.entries ?? []).map(blocklistEntryFromWire);
+    return {
+        entries,
+        count: raw.count ?? 0,
+        status: raw.status ?? "",
+    };
+}
+/** @internal */
+function reportRespFromWire(raw) {
+    return {
+        url: raw.url ?? "",
+        status: raw.status ?? "",
+        message: raw.message ?? "",
+        threatLevel: raw.threat_level,
+    };
+}
+// ── Client methods ───────────────────────────────────────────────
+/**
+ * Scan a URL for prompt injection attacks.
+ * @internal
+ */
+export async function securityScanUrl(client, url) {
+    const { data } = await client._doJSON("POST", "/qai/v1/security/scan-url", { url });
+    return scanRespFromWire(data);
+}
+/**
+ * Scan raw HTML content for prompt injection.
+ * @internal
+ */
+export async function securityScanHtml(client, req) {
+    const { data } = await client._doJSON("POST", "/qai/v1/security/scan-html", scanHtmlToWire(req));
+    return scanRespFromWire(data);
+}
+/**
+ * Check a URL against the injection registry.
+ * @internal
+ */
+export async function securityCheck(client, url) {
+    const { data } = await client._doJSON("GET", `/qai/v1/security/check?url=${encodeURIComponent(url)}`, undefined);
+    return checkRespFromWire(data);
+}
+/**
+ * Get the injection blocklist feed.
+ * @internal
+ */
+export async function securityBlocklist(client, status) {
+    const path = status
+        ? `/qai/v1/security/blocklist?status=${encodeURIComponent(status)}`
+        : "/qai/v1/security/blocklist";
+    const { data } = await client._doJSON("GET", path, undefined);
+    return blocklistRespFromWire(data);
+}
+/**
+ * Report a suspicious URL.
+ * @internal
+ */
+export async function securityReport(client, req) {
+    const { data } = await client._doJSON("POST", "/qai/v1/security/report", req);
+    return reportRespFromWire(data);
+}

package/dist/types.d.ts

@@ -84,12 +84,39 @@ export interface StreamToolUse {
     name: string;
     input: Record<string, unknown>;
 }
+/** New since v0.6: tool-use streaming triplet. */
+export interface StreamToolUseStart {
+    id: string;
+    name: string;
+}
+export interface StreamToolUseInputDelta {
+    id: string;
+    /** Raw JSON fragment — may not parse on its own; accumulate until tool_use_complete. */
+    partial_json: string;
+}
+export interface StreamToolUseComplete {
+    id: string;
+    name: string;
+    /** Server-accumulated, fully-parsed tool arguments. */
+    input: Record<string, unknown>;
+}
 export interface StreamEvent {
     type: string;
-    /** Event type (e.g. "content_delta", "thinking_delta", "tool_use", "usage", "error", "done"). */
+    /** Event type (e.g. "content_delta", "thinking_delta", "tool_use_start",
+     *  "tool_use_input_delta", "tool_use_complete", "tool_use" (legacy),
+     *  "usage", "error", "done"). */
     event_type?: string;
     delta?: StreamDelta;
+    /** Populated for the legacy atomic "tool_use" event. New code should
+     *  prefer the triplet (tool_use_start / tool_use_input_delta /
+     *  tool_use_complete). */
     tool_use?: StreamToolUse;
+    /** Populated for "tool_use_start" events. */
+    tool_use_start?: StreamToolUseStart;
+    /** Populated for "tool_use_input_delta" events. */
+    tool_use_input_delta?: StreamToolUseInputDelta;
+    /** Populated for "tool_use_complete" events. */
+    tool_use_complete?: StreamToolUseComplete;
     usage?: ChatUsage;
     error?: string;
     done?: boolean;
@@ -99,6 +126,11 @@ export interface RawStreamEvent {
     type?: string;
     delta?: StreamDelta;
     tool_use?: StreamToolUse;
+    /** Fields shared by the triplet — flattened in the wire format. */
+    id?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+    partial_json?: string;
     usage?: ChatUsage;
     message?: string;
     input_tokens?: number;
@@ -2208,3 +2240,53 @@ export interface SearchOptions {
     freshness?: string;
     safe_search?: string;
 }
+/** A single scrape target. */
+export interface ScrapeTarget {
+    name: string;
+    url: string;
+    type?: string;
+    selector?: string;
+    content?: string;
+    notebook?: string;
+    recursive?: boolean;
+    max_pages?: number;
+    delay_ms?: number;
+    ingest?: string;
+}
+/** Request body for submitting a scrape job. */
+export interface ScrapeRequest {
+    targets: ScrapeTarget[];
+}
+/** Response from submitting a scrape job. */
+export interface ScrapeResponse {
+    job_id: string;
+    status: string;
+    targets: number;
+    request_id: string;
+}
+/** A single URL to screenshot. */
+export interface ScreenshotURL {
+    url: string;
+    width?: number;
+    height?: number;
+    full_page?: boolean;
+    delay_ms?: number;
+}
+/** Request body for taking screenshots. */
+export interface ScreenshotRequest {
+    urls: ScreenshotURL[];
+}
+/** A single screenshot result. */
+export interface ScreenshotResult {
+    url: string;
+    base64: string;
+    format: string;
+    width: number;
+    height: number;
+    error?: string;
+}
+/** Response from the screenshot endpoint. */
+export interface ScreenshotResponse {
+    screenshots: ScreenshotResult[];
+    count: number;
+}