@inferencesh/sdk 0.6.48 → 0.6.50

package/dist/agent/actions.js

@@ -139,8 +139,18 @@ export function createActions(ctx) {
                 checkTurnEnd(chatData);
             }
         });
+        // Token-by-token streaming state, reset at every assistant-message boundary.
+        const deltaAccum = createLLMDeltaAccumulator();
         // Listen for ChatMessage updates
         manager.addEventListener('chat_messages', (message, fields) => {
+            // A new assistant message starts a new accumulation. The accumulator is
+            // cumulative and shared across the whole connection, so without this the
+            // next message's deltas merge into the previous message's state — and
+            // because concat with "" is a no-op, a turn that is only tool calls
+            // would render the previous message's text as its own.
+            if (message.role === 'assistant' && !getState().messages.some(m => m.id === message.id)) {
+                deltaAccum.reset();
+            }
             updateMessage(message, fields);
         });
         // Listen for AgentRun updates (state transitions, output)
@@ -152,8 +162,6 @@ export function createActions(ctx) {
             if (currentChat)
                 checkTurnEnd({ ...currentChat, active_run: run });
         });
-        // Listen for LLM delta events (token-by-token streaming)
-        const deltaAccum = createLLMDeltaAccumulator();
         manager.addEventListener('delta', (evt) => {
             if (evt && evt.delta) {
                 deltaAccum.apply(evt.delta);

package/dist/api/agents.d.ts

@@ -9,6 +9,9 @@ export interface InternalToolDefinition {
     description: string;
     tools: string[];
     scope: string;
+    /** What this category resolves to when the agent's flag is unset. Opt-in
+     * categories default false; render switches from this rather than assume. */
+    default_enabled: boolean;
 }
 /** Options for creating an agent */
 export interface AgentOptions {

package/dist/api/artifacts.d.ts

@@ -0,0 +1,72 @@
+import { HttpClient } from '../http/client';
+import type { Response } from '../http/response';
+import { ArtifactDTO, ArtifactVersionDTO, ArtifactCreateRequest, ArtifactUpdateRequest, ArtifactPublishRequest, ArtifactContentResponse, CursorListRequest, CursorListResponse } from '../types';
+/**
+ * Artifacts API — small self-contained HTML/Markdown pages published to a
+ * URL, versioned, permissioned, and shareable.
+ */
+export declare class ArtifactsAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List artifacts with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<ArtifactDTO>>>;
+    /**
+     * Get an artifact by ID or short ID
+     */
+    get(id: string): Promise<Response<ArtifactDTO>>;
+    /**
+     * Get an artifact by namespace/name
+     */
+    getByName(namespace: string, name: string): Promise<Response<ArtifactDTO>>;
+    /**
+     * Publish an artifact. Creates it, or publishes a new version when an
+     * artifact with the same name already exists in your namespace.
+     */
+    publish(data: ArtifactCreateRequest): Promise<Response<ArtifactDTO>>;
+    /**
+     * Update metadata (title, description, favicon, shared version pin)
+     */
+    update(id: string, data: ArtifactUpdateRequest): Promise<Response<ArtifactDTO>>;
+    /**
+     * Publish a new version of an existing artifact
+     */
+    publishVersion(id: string, data: ArtifactPublishRequest): Promise<Response<ArtifactDTO>>;
+    /**
+     * Delete an artifact
+     */
+    delete(id: string): Promise<Response<void>>;
+    /**
+     * List versions (newest first)
+     */
+    listVersions(id: string, params?: Partial<CursorListRequest>): Promise<Response<CursorListResponse<ArtifactVersionDTO>>>;
+    /**
+     * Get version metadata (md5, size, hash — no body)
+     */
+    getVersion(id: string, versionId: string): Promise<Response<ArtifactVersionDTO>>;
+    /**
+     * Get the page source. Omit versionId for the viewer-facing version.
+     */
+    getContent(id: string, versionId?: string): Promise<Response<ArtifactContentResponse>>;
+    /**
+     * Pin the version viewers see. Pass an empty string to always share latest.
+     */
+    setSharedVersion(id: string, versionId: string): Promise<Response<ArtifactDTO>>;
+    /**
+     * Transfer ownership
+     */
+    transferOwnership(id: string, newTeamId: string): Promise<Response<ArtifactDTO>>;
+    /**
+     * Update visibility (private, team, org, unlisted, public)
+     */
+    updateVisibility(id: string, visibility: string): Promise<Response<ArtifactDTO>>;
+    /**
+     * URL of the rendered page (wrapped document under the artifact CSP).
+     * Fetch it with credentials and load into a sandboxed iframe via srcdoc.
+     */
+    renderUrl(id: string, options?: {
+        versionId?: string;
+        theme?: 'dark' | 'light';
+    }): string;
+}

package/dist/api/artifacts.js

@@ -0,0 +1,116 @@
+/** Encode UTF-8 page source as base64 so edge firewalls accept <script> in JSON bodies. */
+function encodeContent(content) {
+    if (typeof Buffer !== 'undefined') {
+        return Buffer.from(content, 'utf8').toString('base64');
+    }
+    const bytes = new TextEncoder().encode(content);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i += 0x8000) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + 0x8000));
+    }
+    return btoa(binary);
+}
+/**
+ * Artifacts API — small self-contained HTML/Markdown pages published to a
+ * URL, versioned, permissioned, and shareable.
+ */
+export class ArtifactsAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List artifacts with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/artifacts/list', { data: params });
+    }
+    /**
+     * Get an artifact by ID or short ID
+     */
+    async get(id) {
+        return this.http.request('get', `/artifacts/${id}`);
+    }
+    /**
+     * Get an artifact by namespace/name
+     */
+    async getByName(namespace, name) {
+        return this.http.request('get', `/artifacts/${namespace}/${name}`);
+    }
+    /**
+     * Publish an artifact. Creates it, or publishes a new version when an
+     * artifact with the same name already exists in your namespace.
+     */
+    async publish(data) {
+        const body = { ...data, content: encodeContent(data.content), content_encoding: 'base64' };
+        return this.http.request('post', '/artifacts', { data: body });
+    }
+    /**
+     * Update metadata (title, description, favicon, shared version pin)
+     */
+    async update(id, data) {
+        return this.http.request('post', `/artifacts/${id}`, { data });
+    }
+    /**
+     * Publish a new version of an existing artifact
+     */
+    async publishVersion(id, data) {
+        const body = { ...data, content: encodeContent(data.content), content_encoding: 'base64' };
+        return this.http.request('post', `/artifacts/${id}/versions`, { data: body });
+    }
+    /**
+     * Delete an artifact
+     */
+    async delete(id) {
+        return this.http.request('delete', `/artifacts/${id}`);
+    }
+    /**
+     * List versions (newest first)
+     */
+    async listVersions(id, params) {
+        return this.http.request('post', `/artifacts/${id}/versions/list`, { data: params });
+    }
+    /**
+     * Get version metadata (md5, size, hash — no body)
+     */
+    async getVersion(id, versionId) {
+        return this.http.request('get', `/artifacts/${id}/versions/${versionId}`);
+    }
+    /**
+     * Get the page source. Omit versionId for the viewer-facing version.
+     */
+    async getContent(id, versionId) {
+        const path = versionId ? `/artifacts/${id}/versions/${versionId}/content` : `/artifacts/${id}/content`;
+        return this.http.request('get', path);
+    }
+    /**
+     * Pin the version viewers see. Pass an empty string to always share latest.
+     */
+    async setSharedVersion(id, versionId) {
+        return this.http.request('post', `/artifacts/${id}`, { data: { shared_version_id: versionId } });
+    }
+    /**
+     * Transfer ownership
+     */
+    async transferOwnership(id, newTeamId) {
+        return this.http.request('post', `/artifacts/${id}/transfer`, { data: { team_id: newTeamId } });
+    }
+    /**
+     * Update visibility (private, team, org, unlisted, public)
+     */
+    async updateVisibility(id, visibility) {
+        return this.http.request('post', `/artifacts/${id}/visibility`, { data: { visibility } });
+    }
+    /**
+     * URL of the rendered page (wrapped document under the artifact CSP).
+     * Fetch it with credentials and load into a sandboxed iframe via srcdoc.
+     */
+    renderUrl(id, options) {
+        const params = new URLSearchParams();
+        if (options?.versionId)
+            params.set('version', options.versionId);
+        if (options?.theme)
+            params.set('theme', options.theme);
+        const qs = params.toString();
+        return `${this.http.getBaseUrl()}/artifacts/${id}/render${qs ? `?${qs}` : ''}`;
+    }
+}

package/dist/delta.d.ts

@@ -8,6 +8,14 @@ export declare class DeltaAccumulator {
     private tags;
     private registry;
     constructor(tags: FieldTags, registry?: FieldTagsRegistry);
+    /**
+     * Discard everything accumulated so far. Required at a message boundary: the
+     * accumulator is cumulative, so without a reset the next message's deltas
+     * merge into the previous message's state. Concat makes that invisible for
+     * text — appending "" leaves the old text in place, so a tool-call-only turn
+     * serves the previous message's answer as its own.
+     */
+    reset(): void;
     seed(output: Record<string, any>): void;
     apply(delta: Record<string, any>): void;
     toOutput(): Record<string, any>;

package/dist/delta.js

@@ -57,6 +57,16 @@ export class DeltaAccumulator {
         this.tags = tags;
         this.registry = registry;
     }
+    /**
+     * Discard everything accumulated so far. Required at a message boundary: the
+     * accumulator is cumulative, so without a reset the next message's deltas
+     * merge into the previous message's state. Concat makes that invisible for
+     * text — appending "" leaves the old text in place, so a tool-call-only turn
+     * serves the previous message's answer as its own.
+     */
+    reset() {
+        this.state = {};
+    }
     seed(output) {
         for (const [key, value] of Object.entries(output)) {
             if (value != null)

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export { FlowsAPI } from './api/flows';
 export { FlowRunsAPI } from './api/flow-runs';
 export { EnginesAPI } from './api/engines';
 export { KnowledgeAPI, SkillsAPI } from './api/knowledge';
+export { ArtifactsAPI } from './api/artifacts';
 export { TeamsAPI, type MeResponse } from './api/teams';
 export { SecretsAPI } from './api/secrets';
 export { ApiKeysAPI } from './api/api-keys';
@@ -42,6 +43,7 @@ import { FlowsAPI } from './api/flows';
 import { FlowRunsAPI } from './api/flow-runs';
 import { EnginesAPI } from './api/engines';
 import { KnowledgeAPI, SkillsAPI } from './api/knowledge';
+import { ArtifactsAPI } from './api/artifacts';
 import { TeamsAPI } from './api/teams';
 import { SecretsAPI } from './api/secrets';
 import { ApiKeysAPI } from './api/api-keys';
@@ -91,6 +93,7 @@ export declare class Inference {
     readonly flowRuns: FlowRunsAPI;
     readonly engines: EnginesAPI;
     readonly knowledge: KnowledgeAPI;
+    readonly artifacts: ArtifactsAPI;
     readonly skills: SkillsAPI;
     readonly teams: TeamsAPI;
     readonly secrets: SecretsAPI;

package/dist/index.js

@@ -17,6 +17,7 @@ export { FlowsAPI } from './api/flows';
 export { FlowRunsAPI } from './api/flow-runs';
 export { EnginesAPI } from './api/engines';
 export { KnowledgeAPI, SkillsAPI } from './api/knowledge';
+export { ArtifactsAPI } from './api/artifacts';
 export { TeamsAPI } from './api/teams';
 export { SecretsAPI } from './api/secrets';
 export { ApiKeysAPI } from './api/api-keys';
@@ -48,6 +49,7 @@ import { FlowsAPI } from './api/flows';
 import { FlowRunsAPI } from './api/flow-runs';
 import { EnginesAPI } from './api/engines';
 import { KnowledgeAPI, SkillsAPI } from './api/knowledge';
+import { ArtifactsAPI } from './api/artifacts';
 import { TeamsAPI } from './api/teams';
 import { SecretsAPI } from './api/secrets';
 import { ApiKeysAPI } from './api/api-keys';
@@ -89,6 +91,7 @@ export class Inference {
         this.flowRuns = new FlowRunsAPI(this.http);
         this.engines = new EnginesAPI(this.http);
         this.knowledge = new KnowledgeAPI(this.http);
+        this.artifacts = new ArtifactsAPI(this.http);
         this.skills = new SkillsAPI(this.http);
         this.teams = new TeamsAPI(this.http);
         this.secrets = new SecretsAPI(this.http);