@sitecoreai-labs/sitecoreai-cli 0.0.4 → 0.1.0

package/dist/agents/api/runs.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgent = exports.streamRun = void 0;
+exports.parseRunEvents = parseRunEvents;
+/**
+ * Runs — trigger an agent/flow and consume its Server-Sent event stream.
+ *
+ * `POST /api/chatv2` streams `text/event-stream`. `parseRunEvents` turns
+ * the raw chunks into typed `RunEvent`s; `streamRun` issues a run against
+ * an existing space; `runAgent` is the convenience that creates a space
+ * first. The chatv2 `graphType` selects the target — an agent slug runs a
+ * standard agent, a flow id runs a workflow.
+ */
+const node_crypto_1 = require("node:crypto");
+const request_1 = require("./request");
+const spaces_1 = require("./spaces");
+/** Parse a stream of raw SSE text chunks into typed run events. */
+async function* parseRunEvents(chunks) {
+    let buffer = "";
+    for await (const chunk of chunks) {
+        buffer += chunk.replace(/\r\n/g, "\n");
+        let boundary;
+        while ((boundary = buffer.indexOf("\n\n")) !== -1) {
+            const frame = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            for (const line of frame.split("\n")) {
+                if (!line.startsWith("data:"))
+                    continue;
+                const payload = line.slice(5).trim();
+                if (!payload || payload === "[DONE]")
+                    continue;
+                try {
+                    const event = JSON.parse(payload);
+                    if (event && typeof event.type === "string")
+                        yield event;
+                }
+                catch {
+                    /* skip an unparseable frame rather than abort the run */
+                }
+            }
+        }
+    }
+}
+/** Trigger a run against an existing space and yield its events. */
+const streamRun = (session, input) => parseRunEvents((0, request_1.agentsStream)(session, "/api/chatv2", {
+    method: "POST",
+    signal: input.signal,
+    body: {
+        id: input.spaceId,
+        agentType: "agent",
+        message: {
+            role: "user",
+            parts: [{ type: "text", text: input.message }],
+            id: (0, node_crypto_1.randomUUID)(),
+        },
+        selectedVisibilityType: "private",
+        graphType: input.graphType,
+    },
+}));
+exports.streamRun = streamRun;
+/**
+ * Create a space for an agent and stream a run against it. Each call
+ * creates a new space — they accumulate, the BFF exposes no space delete.
+ */
+const runAgent = async (session, input) => {
+    const title = input.title ?? `scai run — ${input.agentSlug}`;
+    const { spaceId } = await (0, spaces_1.createSpace)(session, {
+        title,
+        target: input.agentSlug,
+        targetKind: "agent",
+    });
+    return {
+        spaceId,
+        events: (0, exports.streamRun)(session, {
+            spaceId,
+            graphType: input.agentSlug,
+            message: input.message,
+            signal: input.signal,
+        }),
+    };
+};
+exports.runAgent = runAgent;

package/dist/agents/api/schema.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Agentic Studio resource shapes.
+ *
+ * Reverse-engineered from HAR captures + the live BFF (see the project
+ * memory `project_scai_agentic_studio_api`). The API is unversioned, so
+ * shapes carry `[key: string]: unknown` index signatures and optional
+ * fields — callers parse defensively and never assume a field is present.
+ */
+/** The tool toggles on an agent's config. Each maps to a `/api/tools` entry. */
+export interface AgentToolToggles {
+    enableArtifacts?: boolean;
+    enableContextRetrieval?: boolean;
+    enableSitecoreContext?: boolean;
+    enableWebSearch?: boolean;
+    enableImageGeneration?: boolean;
+    enableInsightsData?: boolean;
+    enableAgentApiSites?: boolean;
+    enableAgentApiPages?: boolean;
+    enableAgentApiContent?: boolean;
+    enableAgentApiComponents?: boolean;
+    enableAgentApiAssets?: boolean;
+    enableAgentApiPersonalization?: boolean;
+    enableAgentApiJobs?: boolean;
+    enableAgentApiBriefs?: boolean;
+    enableAgentApiBrandKits?: boolean;
+    enableStructuredOutput?: boolean;
+}
+/** Agent output mode. `structured` pairs with a `/api/schemas` schema. */
+export interface AgentOutput {
+    format: "text" | "structured";
+    dynamic?: boolean;
+}
+export interface AgentConfig {
+    /** "standard" for a prompt+tools agent; workflow agents also carry a graph. */
+    executionMode: string;
+    tools: AgentToolToggles;
+    defaultContext: unknown[];
+    /** Skill UUIDs (see `/api/skills`). */
+    skills: string[];
+    output: AgentOutput;
+    /** Workflow agents carry a `nodes` graph here — passed through untyped. */
+    [key: string]: unknown;
+}
+export interface Agent {
+    id: string;
+    slug: string;
+    name?: string;
+    description?: string;
+    prompt?: string;
+    tags?: string[];
+    config?: AgentConfig;
+    isPredefined?: boolean;
+    [key: string]: unknown;
+}
+/** A `/api/tools` catalog entry. `category` is agent_api | context | standard. */
+export interface Tool {
+    id: string;
+    toolKey: string;
+    label: string;
+    description: string;
+    category: string;
+    isEnabled: boolean;
+    accessLevel?: string;
+    updatedAt?: string;
+}
+/**
+ * A `/api/skills` skill — reusable markdown guidance an agent attaches.
+ * `content` is the markdown; `visibility` is e.g. "team" | "private".
+ */
+export interface Skill {
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    content?: string;
+    tags?: string[];
+    visibility?: string;
+    isSystem?: boolean;
+    isEnabled?: boolean;
+    source?: string;
+    ownerUserId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+/** A scheduled run from `/api/scheduled-runs`. */
+export interface ScheduledRun {
+    id: string;
+    name?: string;
+    cronExpression?: string;
+    timezone?: string;
+    status?: string;
+    lastRunAt?: string | null;
+    nextRunAt?: string | null;
+    createdAt?: string;
+    [key: string]: unknown;
+}
+/** One agent slot in a space's config. */
+export interface SpaceAgentRef {
+    /** Agent slug (standard agent) or flow id (workflow). */
+    slug: string;
+    title: string;
+    instanceId: string;
+}
+/** What a run launches. `graphType` is the agent slug or flow id. */
+export interface SpaceLaunchTarget {
+    kind: "agent" | "flow";
+    graphType: string;
+}
+export interface SpaceConfig {
+    purpose: string;
+    workPattern: string;
+    spaceName: string;
+    globalContext: {
+        objective: string;
+    };
+    items: unknown[];
+    agents: SpaceAgentRef[];
+    agentExecutionMode: string;
+    launchTarget?: SpaceLaunchTarget;
+}
+/**
+ * One Server-Sent event from a `chatv2` run. The taxonomy is large and
+ * reverse-engineered (`start`, `text-delta`, `data-workflow-update`,
+ * `data-artifactDelta`, `finish`, …); `type` is always present, the rest
+ * is event-specific.
+ */
+export interface RunEvent {
+    type: string;
+    [key: string]: unknown;
+}
+/**
+ * A widget's declarative UI spec — a tree of typed elements. An element's
+ * props may carry `{ $state: "/path" }` bindings to runtime state.
+ */
+export interface WidgetSpec {
+    root: string;
+    elements: Record<string, unknown>;
+}
+/** A `/api/widgets` widget — a configurable report/dashboard surface. */
+export interface Widget {
+    id: string;
+    name: string;
+    description?: string | null;
+    spec?: WidgetSpec;
+    [key: string]: unknown;
+}
+/** A registered external MCP server (`/api/custom-mcps`). */
+export interface CustomMcp {
+    id: string;
+    name: string;
+    url: string;
+    isEnabled?: boolean;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}
+/** A structured-output schema (`/api/schemas`). */
+export interface StructuredSchema {
+    id?: string;
+    schemaId?: string;
+    name: string;
+    description?: string;
+    /** The JSON-Schema definition (shape varies). */
+    fields?: unknown;
+    tags?: string[];
+    [key: string]: unknown;
+}
+/** An HTML template (`/api/html-templates`). */
+export interface HtmlTemplate {
+    id: string;
+    templateId?: string;
+    name?: string;
+    description?: string;
+    /** The template's HTML body. */
+    code?: string;
+    tags?: string[];
+    contextId?: string | null;
+    createdAt?: string;
+    updatedAt?: string;
+    [key: string]: unknown;
+}

package/dist/agents/api/schema.js

@@ -0,0 +1,10 @@
+"use strict";
+/**
+ * Agentic Studio resource shapes.
+ *
+ * Reverse-engineered from HAR captures + the live BFF (see the project
+ * memory `project_scai_agentic_studio_api`). The API is unversioned, so
+ * shapes carry `[key: string]: unknown` index signatures and optional
+ * fields — callers parse defensively and never assume a field is present.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agents/api/schemas.d.ts

@@ -0,0 +1,37 @@
+import type { AgentsSession } from "../session/types";
+import type { StructuredSchema } from "./schema";
+/** List every structured-output schema visible to the session. */
+export declare const listSchemas: (session: AgentsSession) => Promise<StructuredSchema[]>;
+/** Find one schema by `id`, `schemaId`, or `name`. Returns `undefined` if not found. */
+export declare const getSchema: (session: AgentsSession, idOrName: string) => Promise<StructuredSchema | undefined>;
+export interface CreateSchemaInput {
+    /** Display name and identifier of the schema. */
+    name: string;
+    description?: string;
+    /** The JSON-Schema object the structured output must satisfy. */
+    schema: Record<string, unknown>;
+    /** Enforce the schema strictly. Defaults to true. */
+    strict?: boolean;
+    tags?: string[];
+}
+/**
+ * Create a structured-output schema. **UNSTABLE — see the file header.**
+ *
+ * Replays the `/schemas/create` server action. Throws `AGENTS_API_FAILED`
+ * with a re-capture hint when the action hash has rotated (the most
+ * likely failure after an Agentic Studio deploy).
+ */
+export declare const createSchema: (session: AgentsSession, input: CreateSchemaInput) => Promise<void>;
+export interface UpdateSchemaInput extends CreateSchemaInput {
+    /** Id of the schema to replace. */
+    id: string;
+}
+/**
+ * Update a structured-output schema. There is no REST update
+ * (`PUT /api/schemas/{id}` → 405); instead the `/schemas/create` server
+ * action upserts by name, so an update is a re-create — verified
+ * 2026-05-17. `input.id` is unused: the server action keys on the name.
+ */
+export declare const updateSchema: (session: AgentsSession, input: UpdateSchemaInput) => Promise<void>;
+/** Delete a schema (`DELETE /api/schemas/{id}`). **UNVERIFIED — returned 405; see header.** */
+export declare const deleteSchema: (session: AgentsSession, id: string) => Promise<void>;

package/dist/agents/api/schemas.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSchema = exports.updateSchema = exports.createSchema = exports.getSchema = exports.listSchemas = void 0;
+/**
+ * Structured-output schemas (`/api/schemas`).
+ *
+ * `listSchemas` reads. `createSchema` is **UNSTABLE**: there is no `/api/`
+ * schema-write endpoint, so it replays the `/schemas/create` Next.js
+ * server action via `agentsServerAction` — coupling scai to Agentic
+ * Studio's internal build (the action hash rotates on every deploy). To
+ * be deleted when a real `POST /api/schemas` endpoint ships.
+ *
+ * `updateSchema` re-runs the `/schemas/create` server action — verified
+ * 2026-05-17 (agentic-studio-euw): that action upserts by name, so a
+ * re-create *is* an update (REST `PUT /api/schemas/{id}` returns 405).
+ * `deleteSchema` is still **UNVERIFIED** — `DELETE /api/schemas/{id}`
+ * returns 405 and no delete server action has been captured. See
+ * docs/agentic-studio-har-capture.md.
+ */
+const request_1 = require("./request");
+/** List every structured-output schema visible to the session. */
+const listSchemas = async (session) => {
+    const data = await (0, request_1.agentsRequest)(session, "/api/schemas");
+    return Array.isArray(data) ? data : [];
+};
+exports.listSchemas = listSchemas;
+/** Find one schema by `id`, `schemaId`, or `name`. Returns `undefined` if not found. */
+const getSchema = async (session, idOrName) => {
+    const schemas = await (0, exports.listSchemas)(session);
+    return schemas.find((schema) => schema.id === idOrName || schema.schemaId === idOrName || schema.name === idOrName);
+};
+exports.getSchema = getSchema;
+/**
+ * Last-resort `/schemas/create` server-action hash. The hash ROTATES on
+ * every Agentic Studio deploy; `scai agents login` discovers the current
+ * one and stores it on the session (`session.actionHashes`), so this
+ * constant is only reached when discovery failed AND
+ * `SITECOREAI_SCHEMA_ACTION` is unset.
+ */
+const SCHEMA_CREATE_ACTION = "60087ab4468f98b69c7cd3b32c83a5d7b1ca883ff1";
+/** Router-state-tree the `/schemas/create` action expects. */
+const SCHEMA_CREATE_ROUTER_TREE = '["",{"children":["(settings)",{"children":["schemas",{"children":' +
+    '["create",{"children":["__PAGE__",{},null,null,0]},null,null,0]},null,null,0]},null,null,0]},null,null,20]';
+/** Derive a snake_case structured-output function name from a display name. */
+const toFunctionName = (name) => name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "_")
+    .replace(/^_+|_+$/g, "") || "schema";
+/**
+ * Create a structured-output schema. **UNSTABLE — see the file header.**
+ *
+ * Replays the `/schemas/create` server action. Throws `AGENTS_API_FAILED`
+ * with a re-capture hint when the action hash has rotated (the most
+ * likely failure after an Agentic Studio deploy).
+ */
+const createSchema = async (session, input) => {
+    await (0, request_1.agentsServerAction)(session, "/schemas/create", {
+        actionHash: session.actionHashes?.["/schemas/create"] ??
+            process.env.SITECOREAI_SCHEMA_ACTION ??
+            SCHEMA_CREATE_ACTION,
+        routerStateTree: SCHEMA_CREATE_ROUTER_TREE,
+        // Server-action args: [prevState, payload] in Next.js RSC encoding —
+        // `$undefined` stands in for absent optionals, matching a captured call.
+        args: [
+            null,
+            {
+                schemaId: input.name,
+                name: input.name,
+                description: input.description ?? request_1.RSC_UNDEFINED,
+                fields: {
+                    name: toFunctionName(input.name),
+                    strict: input.strict ?? true,
+                    schema: input.schema,
+                },
+                tags: input.tags ?? request_1.RSC_UNDEFINED,
+            },
+        ],
+    });
+};
+exports.createSchema = createSchema;
+/**
+ * Update a structured-output schema. There is no REST update
+ * (`PUT /api/schemas/{id}` → 405); instead the `/schemas/create` server
+ * action upserts by name, so an update is a re-create — verified
+ * 2026-05-17. `input.id` is unused: the server action keys on the name.
+ */
+const updateSchema = async (session, input) => {
+    await (0, exports.createSchema)(session, input);
+};
+exports.updateSchema = updateSchema;
+/** Delete a schema (`DELETE /api/schemas/{id}`). **UNVERIFIED — returned 405; see header.** */
+const deleteSchema = async (session, id) => {
+    await (0, request_1.agentsRequest)(session, `/api/schemas/${encodeURIComponent(id)}`, { method: "DELETE" });
+};
+exports.deleteSchema = deleteSchema;

package/dist/agents/api/skills.d.ts

@@ -0,0 +1,25 @@
+import type { AgentsSession } from "../session/types";
+import type { Skill } from "./schema";
+/** List every skill visible to the session. */
+export declare const listSkills: (session: AgentsSession) => Promise<Skill[]>;
+/** Find one skill by `id` or `slug`. */
+export declare const getSkill: (session: AgentsSession, idOrSlug: string) => Promise<Skill | undefined>;
+export interface CreateSkillInput {
+    name: string;
+    description: string;
+    /** The skill's markdown guidance. */
+    content: string;
+    tags?: string[];
+    /** "team" (default) | "private". */
+    visibility?: string;
+}
+/** Create a skill (`POST /api/skills`). */
+export declare const createSkill: (session: AgentsSession, input: CreateSkillInput) => Promise<Skill>;
+export interface UpdateSkillInput extends CreateSkillInput {
+    /** Id of the skill to replace. */
+    id: string;
+}
+/** Update a skill (`PUT /api/skills/{id}`, full-replacement). */
+export declare const updateSkill: (session: AgentsSession, input: UpdateSkillInput) => Promise<void>;
+/** Delete a skill (`DELETE /api/skills/{id}`). */
+export declare const deleteSkill: (session: AgentsSession, id: string) => Promise<void>;

package/dist/agents/api/skills.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteSkill = exports.updateSkill = exports.createSkill = exports.getSkill = exports.listSkills = void 0;
+/**
+ * Skills — reusable markdown guidance an agent attaches (`/api/skills`).
+ *
+ * `POST /api/skills` returns the created skill directly (not wrapped in an
+ * array, unlike `/api/agents`). `updateSkill` / `deleteSkill` use
+ * `PUT`/`DELETE /api/skills/{id}` — verified working 2026-05-17 against
+ * agentic-studio-euw (a probe created, updated, and deleted a skill).
+ */
+const request_1 = require("./request");
+/** List every skill visible to the session. */
+const listSkills = async (session) => {
+    const data = await (0, request_1.agentsRequest)(session, "/api/skills");
+    return Array.isArray(data) ? data : [];
+};
+exports.listSkills = listSkills;
+/** Find one skill by `id` or `slug`. */
+const getSkill = async (session, idOrSlug) => {
+    const skills = await (0, exports.listSkills)(session);
+    return skills.find((skill) => skill.id === idOrSlug || skill.slug === idOrSlug);
+};
+exports.getSkill = getSkill;
+/** Create a skill (`POST /api/skills`). */
+const createSkill = async (session, input) => (0, request_1.agentsRequest)(session, "/api/skills", {
+    method: "POST",
+    body: {
+        name: input.name,
+        description: input.description,
+        content: input.content,
+        tags: input.tags ?? [],
+        visibility: input.visibility ?? "team",
+    },
+});
+exports.createSkill = createSkill;
+/** Update a skill (`PUT /api/skills/{id}`, full-replacement). */
+const updateSkill = async (session, input) => {
+    await (0, request_1.agentsRequest)(session, `/api/skills/${encodeURIComponent(input.id)}`, {
+        method: "PUT",
+        body: {
+            name: input.name,
+            description: input.description,
+            content: input.content,
+            tags: input.tags ?? [],
+            visibility: input.visibility ?? "team",
+        },
+    });
+};
+exports.updateSkill = updateSkill;
+/** Delete a skill (`DELETE /api/skills/{id}`). */
+const deleteSkill = async (session, id) => {
+    await (0, request_1.agentsRequest)(session, `/api/skills/${encodeURIComponent(id)}`, { method: "DELETE" });
+};
+exports.deleteSkill = deleteSkill;

package/dist/agents/api/spaces.d.ts

@@ -0,0 +1,34 @@
+import type { AgentsSession } from "../session/types";
+import type { SpaceConfig } from "./schema";
+/** Build a single-agent space config bound to one launch target. */
+export declare const buildSpaceConfig: (title: string, target: string, kind: "agent" | "flow") => SpaceConfig;
+export interface CreateSpaceInput {
+    title: string;
+    /** Agent slug (standard agent) or flow id (workflow) to bind and launch. */
+    target: string;
+    /** Defaults to "agent". */
+    targetKind?: "agent" | "flow";
+}
+export interface CreatedSpace {
+    spaceId: string;
+    config: SpaceConfig;
+}
+/** Create a space for one agent/flow and persist its config. */
+export declare const createSpace: (session: AgentsSession, input: CreateSpaceInput) => Promise<CreatedSpace>;
+/** Read a space's stored config (`GET /api/spaces/{id}/config`). */
+export declare const getSpaceConfig: (session: AgentsSession, spaceId: string) => Promise<SpaceConfig>;
+/** A space's run artifacts — the structured results of its agent runs. */
+export interface SpaceArtifacts {
+    ok?: boolean;
+    /** The artifact payload; shape is run-specific and parsed defensively. */
+    data?: unknown;
+    [key: string]: unknown;
+}
+/** Read a space's run artifacts / output (`GET /api/spaces/{id}/artifacts`). */
+export declare const getSpaceArtifacts: (session: AgentsSession, spaceId: string) => Promise<SpaceArtifacts>;
+/**
+ * Replace a space's config (`PUT /api/spaces/{id}/config`). The BFF has no
+ * space delete; rewriting the config is how a space is renamed or has its
+ * agents / global context changed.
+ */
+export declare const updateSpaceConfig: (session: AgentsSession, spaceId: string, config: SpaceConfig) => Promise<void>;

package/dist/agents/api/spaces.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSpaceConfig = exports.getSpaceArtifacts = exports.getSpaceConfig = exports.createSpace = exports.buildSpaceConfig = void 0;
+/**
+ * Spaces — the container a run executes in.
+ *
+ * A run targets a *space*, not an agent directly. `createSpace` builds a
+ * single-agent space and writes its config: the BFF expects the config
+ * both in the `POST /api/spaces` body and via a follow-up
+ * `PUT /api/spaces/{id}/config` (the order observed in the UI).
+ *
+ * The space's `launchTarget` is what the run engine actually launches.
+ *
+ * Verified 2026-05-17 (agentic-studio-euw): a space has no list or delete
+ * endpoint (`GET /api/spaces` → 405, `GET`/`DELETE /api/spaces/{id}` →
+ * 404), but `/config` and `/artifacts` are readable and `/config` is
+ * writable — so a space can be read, renamed, and have its agents /
+ * context changed, just not enumerated or deleted.
+ */
+const node_crypto_1 = require("node:crypto");
+const request_1 = require("./request");
+/** Build a single-agent space config bound to one launch target. */
+const buildSpaceConfig = (title, target, kind) => ({
+    purpose: "custom",
+    workPattern: "custom-orchestration",
+    spaceName: title,
+    globalContext: { objective: "" },
+    items: [],
+    agents: [{ slug: target, title, instanceId: (0, node_crypto_1.randomUUID)() }],
+    agentExecutionMode: "sequential",
+    launchTarget: { kind, graphType: target },
+});
+exports.buildSpaceConfig = buildSpaceConfig;
+/** Create a space for one agent/flow and persist its config. */
+const createSpace = async (session, input) => {
+    const spaceId = (0, node_crypto_1.randomUUID)();
+    const config = (0, exports.buildSpaceConfig)(input.title, input.target, input.targetKind ?? "agent");
+    await (0, request_1.agentsRequest)(session, "/api/spaces", {
+        method: "POST",
+        body: { id: spaceId, title: input.title, spaceConfig: config },
+    });
+    await (0, request_1.agentsRequest)(session, `/api/spaces/${spaceId}/config`, {
+        method: "PUT",
+        body: { spaceConfig: config },
+    });
+    return { spaceId, config };
+};
+exports.createSpace = createSpace;
+/** Read a space's stored config (`GET /api/spaces/{id}/config`). */
+const getSpaceConfig = async (session, spaceId) => {
+    const data = await (0, request_1.agentsRequest)(session, `/api/spaces/${encodeURIComponent(spaceId)}/config`);
+    return (data?.spaceConfig ?? {});
+};
+exports.getSpaceConfig = getSpaceConfig;
+/** Read a space's run artifacts / output (`GET /api/spaces/{id}/artifacts`). */
+const getSpaceArtifacts = async (session, spaceId) => {
+    const data = await (0, request_1.agentsRequest)(session, `/api/spaces/${encodeURIComponent(spaceId)}/artifacts`);
+    return data ?? {};
+};
+exports.getSpaceArtifacts = getSpaceArtifacts;
+/**
+ * Replace a space's config (`PUT /api/spaces/{id}/config`). The BFF has no
+ * space delete; rewriting the config is how a space is renamed or has its
+ * agents / global context changed.
+ */
+const updateSpaceConfig = async (session, spaceId, config) => {
+    await (0, request_1.agentsRequest)(session, `/api/spaces/${encodeURIComponent(spaceId)}/config`, {
+        method: "PUT",
+        body: { spaceConfig: config },
+    });
+};
+exports.updateSpaceConfig = updateSpaceConfig;

package/dist/agents/api/tools.d.ts

@@ -0,0 +1,4 @@
+import type { AgentsSession } from "../session/types";
+import type { Tool } from "./schema";
+/** List the tool catalog. `category` is agent_api | context | standard. */
+export declare const listTools: (session: AgentsSession) => Promise<Tool[]>;

package/dist/agents/api/tools.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listTools = void 0;
+/**
+ * Tools — the platform tool catalog (`/api/tools`).
+ *
+ * Tools are NOT user-created: they are a fixed catalog (the `enableAgentApi*`
+ * Agent-API domains, plus context MCPs and standard tools). An agent opts
+ * into them via its `config.tools` toggles. Admin enable/disable goes
+ * through `PATCH /api/tools/{toolKey}` — out of scope here until needed.
+ */
+const request_1 = require("./request");
+/** List the tool catalog. `category` is agent_api | context | standard. */
+const listTools = async (session) => {
+    const data = await (0, request_1.agentsRequest)(session, "/api/tools");
+    return Array.isArray(data) ? data : [];
+};
+exports.listTools = listTools;

package/dist/agents/api/widgets.d.ts

@@ -0,0 +1,32 @@
+import type { AgentsSession } from "../session/types";
+import type { Widget, WidgetSpec } from "./schema";
+/** List every widget visible to the session. */
+export declare const listWidgets: (session: AgentsSession) => Promise<Widget[]>;
+/** Find one widget by `id` or `name`. Returns `undefined` if not found. */
+export declare const getWidget: (session: AgentsSession, idOrName: string) => Promise<Widget | undefined>;
+export interface CreateWidgetInput {
+    name: string;
+    description?: string | null;
+    spec: WidgetSpec;
+}
+/** Create a widget (`POST /api/widgets`). */
+export declare const createWidget: (session: AgentsSession, input: CreateWidgetInput) => Promise<Widget>;
+export interface UpdateWidgetInput extends CreateWidgetInput {
+    /** Id of the widget to replace. */
+    id: string;
+}
+/** Update a widget (`PUT /api/widgets/{id}`, full-replacement). */
+export declare const updateWidget: (session: AgentsSession, input: UpdateWidgetInput) => Promise<void>;
+/** Delete a widget (`DELETE /api/widgets/{id}`). */
+export declare const deleteWidget: (session: AgentsSession, id: string) => Promise<void>;
+/** A JSON-Patch op emitted by `generateWidgetSpec`. */
+export interface WidgetSpecPatch {
+    op: string;
+    path: string;
+    value?: unknown;
+}
+/**
+ * AI-assisted widget-spec generation (`POST /api/generate-spec`). Streams
+ * newline-delimited JSON-Patch ops that progressively build a `WidgetSpec`.
+ */
+export declare function generateWidgetSpec(session: AgentsSession, prompt: string, currentSpec?: WidgetSpec): AsyncIterable<WidgetSpecPatch>;