@inferencesh/sdk 0.16.0 → 0.18.0

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.18.0] - 2026-10-04
+
+### Added
+
+- `AgentPermissions` and `permissions` on agent configs: what an agent's new chats may do without asking (`allow_all_tools`).
+- `PolicyKind` (`RemoteExec`, `Workspace`, `Harness`, `Tool`, `WebFetch`, and the usage kinds `App`, `Agent`, `Knowledge`, `Mcp`, `Flow`) with its constants. `PolicyRuleDTO.kind` is a `PolicyKind`.
+
+### Removed
+
+- `ChatData.always_allowed_tools`. A chat's always-allow list became chat rules (`GET /chats/{id}/rules`); the api no longer sends it.
+- `TeamDTO.usage_policy_id`. A workspace's usage policy is a policy attached to it; the org's workspace list carries it.
+
+## [0.17.0] - 2026-10-02
+
+### Changed
+
+- `updateChatSettings` and `switchAgent` merge what the api now answers with into the chat they hold: `ChatSettingsDTO` (`chat_id`, `name`, `visibility`, `allow_all_tools`, `disable_hooks`, `memory`) from `POST /chats/{id}/settings` and `ChatAgentDTO` (`chat_id`, `agent_id`, `agent`, `agent_version_id`, `agent_version`) from `POST /chats/{id}/agent`. The reducer has `MERGE_CHAT_SETTINGS` and `MERGE_CHAT_AGENT` for them; a response for a chat other than the one on screen is ignored. The low-level `updateChatSettings` and `setAgent` in the agent api return those types. Needs an api that answers with them.
+- `ChatDTO.chat_messages` is optional: the api leaves it out when it did not load the messages, which it never does on the chat endpoints. Read messages from `GET /chats/{id}/messages`.
+
+### Fixed
+
+- Polling `sendMessage` handled a fetched chat with an unchanged status only when it carried `chat_messages`. It now skips only the poll's own "nothing changed" answer.
+
 ## [0.16.0] - 2026-10-02
 
 ### Added

package/dist/agent/actions.js

@@ -414,9 +414,7 @@ export function createActions(ctx) {
                 return;
             }
             try {
-                // The response carries the chat without its messages: update the
-                // chat and keep the conversation on screen.
-                dispatch({ type: 'UPDATE_CHAT', payload: await api.updateChatSettings(client, chatId, settings) });
+                dispatch({ type: 'MERGE_CHAT_SETTINGS', payload: await api.updateChatSettings(client, chatId, settings) });
             }
             catch (error) {
                 console.error('[AgentSDK] Failed to change chat settings:', error);
@@ -433,7 +431,7 @@ export function createActions(ctx) {
                 return;
             }
             try {
-                dispatch({ type: 'UPDATE_CHAT', payload: await api.setAgent(client, chatId, agentRef) });
+                dispatch({ type: 'MERGE_CHAT_AGENT', payload: await api.setAgent(client, chatId, agentRef) });
             }
             catch (error) {
                 console.error('[AgentSDK] Failed to switch the agent:', error);

package/dist/agent/api.d.ts

@@ -7,7 +7,7 @@
  *
  * /agents/run stays for A2A/programmatic use.
  */
-import type { AlwaysAllowOptionsDTO, AlwaysAllowResultDTO, ChatDTO, ChatMessageDTO, ChatSettingsRequest, InterruptDTO, ToolExplanationDTO } from '../types';
+import type { AlwaysAllowOptionsDTO, AlwaysAllowResultDTO, ChatAgentDTO, ChatDTO, ChatMessageDTO, ChatSettingsDTO, ChatSettingsRequest, InterruptDTO, ToolExplanationDTO } from '../types';
 import type { AgentOptions, AgentClient, AgentInfo, FileRef } from './types';
 export interface SendResult {
     chatId: string;
@@ -36,7 +36,8 @@ export declare function fetchMessagesPage(client: AgentClient, chatId: string, o
 export declare function fetchChat(client: AgentClient, chatId: string): Promise<ChatDTO | null>;
 export declare function stopChat(client: AgentClient, chatId: string): Promise<void>;
 export declare function cancelMessage(client: AgentClient, messageId: string): Promise<void>;
-export declare function setAgent(client: AgentClient, chatId: string, agentRef: string): Promise<ChatDTO>;
+/** Hand the chat to another agent. Answers with the agent the chat now runs on. */
+export declare function setAgent(client: AgentClient, chatId: string, agentRef: string): Promise<ChatAgentDTO>;
 export declare function submitToolResult(client: AgentClient, toolInvocationId: string, resultOrAction: string | {
     action: {
         type: string;
@@ -63,7 +64,8 @@ export declare function alwaysAllowTool(client: AgentClient, chatId: string, too
  * for the call, so asking again is free.
  */
 export declare function explainTool(client: AgentClient, chatId: string, toolInvocationId: string): Promise<ToolExplanationDTO>;
-export declare function updateChatSettings(client: AgentClient, chatId: string, settings: ChatSettingsRequest): Promise<ChatDTO>;
+/** Change the chat's settings. Answers with the settings as they now are. */
+export declare function updateChatSettings(client: AgentClient, chatId: string, settings: ChatSettingsRequest): Promise<ChatSettingsDTO>;
 export declare function resolveInterrupt(client: AgentClient, interruptId: string, decision: 'allow' | 'deny'): Promise<InterruptDTO>;
 export declare function listRunInterrupts(client: AgentClient, runId: string): Promise<InterruptDTO[]>;
 export declare function uploadFile(client: AgentClient, file: globalThis.File): Promise<FileRef>;

package/dist/agent/api.js

@@ -132,6 +132,7 @@ export async function stopChat(client, chatId) {
 export async function cancelMessage(client, messageId) {
     await client.http.request('post', `/chats/messages/${messageId}/cancel`);
 }
+/** Hand the chat to another agent. Answers with the agent the chat now runs on. */
 export async function setAgent(client, chatId, agentRef) {
     const resp = await client.http.request('post', `/chats/${chatId}/agent`, {
         data: { agent: agentRef },
@@ -178,6 +179,7 @@ export async function explainTool(client, chatId, toolInvocationId) {
     const resp = await client.http.request('post', `/chats/${chatId}/tools/${toolInvocationId}/explain`);
     return resp.data;
 }
+/** Change the chat's settings. Answers with the settings as they now are. */
 export async function updateChatSettings(client, chatId, settings) {
     const resp = await client.http.request('post', `/chats/${chatId}/settings`, { data: settings });
     return resp.data;

package/dist/agent/reducer.js

@@ -50,6 +50,43 @@ export function chatReducer(state, action) {
                 return state;
             return { ...state, chat };
         }
+        // The settings and set-agent endpoints answer with only what they wrote.
+        // Merge it into the chat it belongs to; a chat switched away from in the
+        // meantime is left alone.
+        case 'MERGE_CHAT_SETTINGS': {
+            const settings = action.payload;
+            if (!state.chat || state.chat.id !== settings.chat_id)
+                return state;
+            return {
+                ...state,
+                chat: {
+                    ...state.chat,
+                    name: settings.name,
+                    visibility: settings.visibility,
+                    agent_data: {
+                        ...state.chat.agent_data,
+                        allow_all_tools: settings.allow_all_tools,
+                        disable_hooks: settings.disable_hooks,
+                        memory: settings.memory,
+                    },
+                },
+            };
+        }
+        case 'MERGE_CHAT_AGENT': {
+            const agent = action.payload;
+            if (!state.chat || state.chat.id !== agent.chat_id)
+                return state;
+            return {
+                ...state,
+                chat: {
+                    ...state.chat,
+                    agent_id: agent.agent_id,
+                    agent: agent.agent,
+                    agent_version_id: agent.agent_version_id,
+                    agent_version: agent.agent_version,
+                },
+            };
+        }
         case 'UPDATE_ACTIVE_RUN': {
             if (!state.chat)
                 return state;

package/dist/agent/types.d.ts

@@ -4,7 +4,7 @@
  * Public types for the Agent chat module.
  */
 import type { Dispatch } from 'react';
-import type { AgentRunDTO, AgentVersionDTO, AlwaysAllowOptionsDTO, AlwaysAllowResultDTO, ToolExplanationDTO, ChatDTO, ChatMessageDTO, ChatSettingsRequest, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef, ElicitResult } from '../types';
+import type { AgentRunDTO, AgentVersionDTO, AlwaysAllowOptionsDTO, AlwaysAllowResultDTO, ToolExplanationDTO, ChatAgentDTO, ChatDTO, ChatMessageDTO, ChatSettingsDTO, ChatSettingsRequest, AgentTool, AgentConfigInput as GeneratedAgentConfig, CoreAppConfigInput as CoreAppConfig, FileRef, ElicitResult } from '../types';
 import type { HttpClient } from '../http/client';
 import type { StreamableManager } from '../http/streamable';
 import type { PollManager } from '../http/poll';
@@ -233,6 +233,12 @@ export type ChatAction = {
 } | {
     type: 'UPDATE_CHAT';
     payload: ChatDTO | null;
+} | {
+    type: 'MERGE_CHAT_SETTINGS';
+    payload: ChatSettingsDTO;
+} | {
+    type: 'MERGE_CHAT_AGENT';
+    payload: ChatAgentDTO;
 } | {
     type: 'UPDATE_ACTIVE_RUN';
     payload: AgentRunDTO;

package/dist/api/agents.js

@@ -296,6 +296,10 @@ export class Agent {
         const intervalMs = options.pollIntervalMs ?? this.http.getPollIntervalMs();
         let prevStatus = null;
         let knownMessageIds = new Set();
+        // Returned by the poll when nothing changed. Compared by identity: a
+        // fetched chat never carries chat_messages, so their absence cannot tell
+        // the two apart.
+        const unchanged = {};
         return new Promise((resolve) => {
             this.poller?.stop();
             this.poller = new PollManager({
@@ -305,17 +309,15 @@ export class Agent {
                     const status = statusResp.data;
                     // Unchanged status is skipped — unless the turn is still ungated: a run
                     // that started and finished between two polls only shows in the messages.
-                    if (status.status === prevStatus && gate.settled) {
-                        // No change — return a stub to skip processing
-                        return { status: status.status };
-                    }
+                    if (status.status === prevStatus && gate.settled)
+                        return unchanged;
                     // Status changed — fetch full chat
                     const chatResp = await this.http.request('get', `/chats/${this.chatId}`);
                     return chatResp.data;
                 },
                 intervalMs,
                 onData: (chat) => {
-                    if (chat.status === prevStatus && !chat.chat_messages)
+                    if (chat === unchanged)
                         return;
                     prevStatus = chat.status;
                     options.onChat?.(chat);

package/dist/types.d.ts

@@ -18,6 +18,22 @@ export interface InternalToolsConfig {
     remote?: boolean;
     knowledge?: boolean;
 }
+/**
+ * AgentPermissions is what an agent's new chats in its own workspace may do
+ * without asking (INF-906). Each is copied into such a chat when it is
+ * created; the chat owns it from then on. Chats other workspaces start with
+ * the agent get none of it: they run on their own remotes and tools. A team
+ * or org policy still asks or denies over it.
+ */
+export interface AgentPermissions {
+    /**
+     * AllowAllTools starts each new chat with "allow every tool" on: loop
+     * tools, harness tools and remote_exec commands run without asking. For
+     * agents nobody watches (webhook and cron runs), where an approval would
+     * stall the run.
+     */
+    allow_all_tools?: boolean;
+}
 /**
  * AgentTool represents a unified tool that can be used by an agent
  */
@@ -254,6 +270,7 @@ export interface AgentVersionDTO extends BaseModelDTO, PermissionModelDTO {
     skills: SkillConfig[];
     context?: ContextField[];
     internal_tools?: InternalToolsConfig;
+    permissions?: AgentPermissions;
     hooks?: LifecycleHookConfig[];
     output_schema?: any;
 }
@@ -287,6 +304,7 @@ export interface AgentConfigInput {
     skills?: SkillConfig[];
     context?: ContextField[];
     internal_tools?: InternalToolsConfig;
+    permissions?: AgentPermissions;
     hooks?: LifecycleHookConfig[];
     output_schema?: any;
 }
@@ -1777,6 +1795,37 @@ export interface ChatSettingsRequest {
      */
     forget_memory?: string[];
 }
+/**
+ * ChatSettingsDTO is what POST /chats/{id}/settings answers with: the chat's
+ * settings after the change, every field the endpoint writes and nothing
+ * else. A client merges it into the chat it holds.
+ */
+export interface ChatSettingsDTO {
+    chat_id: string;
+    name: string;
+    visibility: Visibility;
+    /**
+     * AllowAllTools and DisableHooks are agent_data.allow_all_tools and
+     * agent_data.disable_hooks on the chat.
+     */
+    allow_all_tools: boolean;
+    disable_hooks: boolean;
+    /**
+     * Memory is agent_data.memory after forget_memory removed its keys.
+     */
+    memory: StringEncodedMap;
+}
+/**
+ * ChatAgentDTO is what POST /chats/{id}/agent answers with: the agent the
+ * chat now runs on. A client merges it into the chat it holds.
+ */
+export interface ChatAgentDTO {
+    chat_id: string;
+    agent_id: string;
+    agent?: AgentDTO;
+    agent_version_id: string;
+    agent_version?: AgentVersionDTO;
+}
 /**
  * ChatDTO for API responses
  */
@@ -1800,7 +1849,12 @@ export interface ChatDTO extends BaseModelDTO, PermissionModelDTO {
     agent_version?: AgentVersionDTO;
     name: string;
     description: string;
-    chat_messages: ChatMessageDTO[];
+    /**
+     * ChatMessages is left out when the messages were not loaded. The chat
+     * endpoints do not load them; read them from GET /chats/{id}/messages.
+     * An absent field says nothing about whether the chat has messages.
+     */
+    chat_messages?: ChatMessageDTO[];
     agent_data: ChatData;
     active_run?: AgentRunDTO;
     pending_interrupts?: InterruptDTO[];
@@ -1834,13 +1888,6 @@ export interface ChatMessageDTO extends BaseModelDTO, PermissionModelDTO {
     tool_call_id?: string;
     tool_invocations?: ToolInvocationDTO[];
 }
-/**
- * PolicyEffect is a rule's outcome: allow, ask or deny.
- */
-export type PolicyEffect = "allow" | "ask" | "deny";
-export declare const PolicyEffectAllow: PolicyEffect;
-export declare const PolicyEffectAsk: PolicyEffect;
-export declare const PolicyEffectDeny: PolicyEffect;
 /**
  * PolicyRuleDTO is one rule, typed form Kind[selector](specifier).
  */
@@ -1848,10 +1895,10 @@ export interface PolicyRuleDTO {
     id: string;
     effect: PolicyEffect;
     /**
-     * Kind: RemoteExec, Workspace, Harness, Tool (and, from phase 3, App,
-     * Agent, Knowledge, Mcp, Flow, WebFetch).
+     * Kind: what the rule governs (RemoteExec, Workspace, Harness, Tool,
+     * and the usage kinds App, Agent, Knowledge, Mcp, Flow).
      */
-    kind: string;
+    kind: PolicyKind;
     /**
      * Selector narrows the rule to one remote (its id) or a tag (tag:<name>);
      * empty applies everywhere.
@@ -4121,11 +4168,6 @@ export interface TeamDTO extends BaseModelDTO {
      * org it is without belonging to the org workspace.
      */
     org_name?: string;
-    /**
-     * UsagePolicyID of the team's own usage policy ('' = inherit the org's,
-     * or ungoverned when standalone, INF-808).
-     */
-    usage_policy_id?: string;
 }
 /**
  * TeamMemberDTO is the API response for a team member.
@@ -4679,7 +4721,6 @@ export declare const ChannelTypeTelegram: ChannelType;
 export interface ChatData {
     plan_steps: PlanStep[];
     memory: StringEncodedMap;
-    always_allowed_tools: string[];
     /**
      * AllowAllTools runs every tool call in this chat without asking. The
      * person switches it in the chat's settings, and off again at any time.
@@ -5507,6 +5548,46 @@ export declare const NotificationStatusDelivered: NotificationStatus;
 export declare const NotificationStatusFailed: NotificationStatus;
 export declare const NotificationStatusBounced: NotificationStatus;
 export declare const NotificationStatusCancelled: NotificationStatus;
+/**
+ * PolicyEffect is a rule's outcome and a decision's verdict.
+ */
+export type PolicyEffect = "allow" | "ask" | "deny";
+export declare const PolicyEffectAllow: PolicyEffect;
+export declare const PolicyEffectAsk: PolicyEffect;
+export declare const PolicyEffectDeny: PolicyEffect;
+/**
+ * PolicyKind names what a rule governs; each kind has one matcher.
+ */
+export type PolicyKind = "RemoteExec" | "Workspace" | "Harness" | "Tool" | "App" | "Agent" | "Knowledge" | "Mcp" | "Flow" | "WebFetch";
+/**
+ * PolicyKindRemoteExec: shell commands run on a remote.
+ */
+export declare const PolicyKindRemoteExec: PolicyKind;
+/**
+ * PolicyKindWorkspace: folders on a remote.
+ */
+export declare const PolicyKindWorkspace: PolicyKind;
+/**
+ * PolicyKindHarness: a harness's own tool approvals, e.g.
+ * Harness(Bash(git status:*)).
+ */
+export declare const PolicyKindHarness: PolicyKind;
+/**
+ * PolicyKindTool: a tool call our own agent loop makes, by tool name.
+ */
+export declare const PolicyKindTool: PolicyKind;
+/**
+ * Usage kinds (UsageCategory.PolicyKind): rules name resolved ids.
+ */
+export declare const PolicyKindApp: PolicyKind;
+export declare const PolicyKindAgent: PolicyKind;
+export declare const PolicyKindKnowledge: PolicyKind;
+export declare const PolicyKindMcp: PolicyKind;
+export declare const PolicyKindFlow: PolicyKind;
+/**
+ * PolicyKindWebFetch: fetched domains.
+ */
+export declare const PolicyKindWebFetch: PolicyKind;
 /**
  * FunctionKind is how an app function talks to its caller.
  */

package/dist/types.js

@@ -302,9 +302,6 @@ export const ScopeGroupKnowledge = "knowledge";
 export const ScopeGroupArtifacts = "artifacts";
 export const ScopeGroupUser = "user";
 export const ScopeGroupSettings = "settings";
-export const PolicyEffectAllow = "allow";
-export const PolicyEffectAsk = "ask";
-export const PolicyEffectDeny = "deny";
 /**
  * AlwaysAllowScopeExact: this call exactly (each piece of the command,
  * the file, the domain).
@@ -1066,6 +1063,38 @@ export const NotificationStatusDelivered = "delivered";
 export const NotificationStatusFailed = "failed";
 export const NotificationStatusBounced = "bounced";
 export const NotificationStatusCancelled = "cancelled";
+export const PolicyEffectAllow = "allow";
+export const PolicyEffectAsk = "ask";
+export const PolicyEffectDeny = "deny";
+/**
+ * PolicyKindRemoteExec: shell commands run on a remote.
+ */
+export const PolicyKindRemoteExec = "RemoteExec";
+/**
+ * PolicyKindWorkspace: folders on a remote.
+ */
+export const PolicyKindWorkspace = "Workspace";
+/**
+ * PolicyKindHarness: a harness's own tool approvals, e.g.
+ * Harness(Bash(git status:*)).
+ */
+export const PolicyKindHarness = "Harness";
+/**
+ * PolicyKindTool: a tool call our own agent loop makes, by tool name.
+ */
+export const PolicyKindTool = "Tool";
+/**
+ * Usage kinds (UsageCategory.PolicyKind): rules name resolved ids.
+ */
+export const PolicyKindApp = "App";
+export const PolicyKindAgent = "Agent";
+export const PolicyKindKnowledge = "Knowledge";
+export const PolicyKindMcp = "Mcp";
+export const PolicyKindFlow = "Flow";
+/**
+ * PolicyKindWebFetch: fetched domains.
+ */
+export const PolicyKindWebFetch = "WebFetch";
 /**
  * FunctionKindRun takes an input and returns an output (optionally
  * yielding progress on the way). The zero value means this.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inferencesh/sdk",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Official JavaScript/TypeScript SDK for inference.sh - Run AI models with a simple API",
   "type": "module",
   "main": "dist/index.js",