@inferencesh/sdk 0.13.0 → 0.14.1

package/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.14.1] - 2026-10-01
+
+### Added
+
+- `internalTools()` builder methods for every category: `knowledge()` (search, read, save and delete skills and knowledge entries), `agent()` (run a copy of the agent on a side task), `skills()`, `artifact()` and `remote()`.
+- `InternalToolsConfig.knowledge` and `InternalToolsConfig.agent`.
+
+### Changed
+
+- `InternalToolsConfig.spawn` is now `agent`. The API still reads a stored or sent `spawn` as `agent`.
+
+### Deprecated
+
+- `InternalToolsConfig.host_context`: the API ignores it and no longer offers `get_host_context` or `send_to_host`.
+
+## [0.14.0] - 2026-09-27
+
+### Fixed
+
+- `tasks.create()` returns `TaskResultDTO`, what `POST /apps/run` sends (id, status, output, socket), instead of claiming a full `Task`. `run(..., { wait: false })` fetches the full task with `GET /tasks/{id}` before returning it.
+- `teams.list()`, `get()`, `create()` and `update()` return `TeamDTO`, what the server sends, instead of `TeamRelationDTO`.
+- `MeResponse` is the generated type (adds `org`, `team_view` and `diagnostics`; `team` is a `TeamDTO`) instead of a hand-written one.
+
 ## [0.8.0] - 2026-09-24
 
 ### Removed

package/README.md

@@ -378,7 +378,7 @@ Use the fluent builders to define `AgentTool` schemas. Client tools (`tool`) run
 | `httpTool(name, url)` / `callTool(name, url)` | Server | HTTP request with credential injection (preferred over `webhookTool`) |
 | `webhookTool(name, url)` | Server | Unsigned webhook (legacy; use `httpTool` for new tools) |
 | `mcpTool(name, credentialId, toolName)` | Server | Call a tool through a connected MCP credential |
-| `internalTools()` | Server | Built-in plan, memory, and widget tools |
+| `internalTools()` | Server | Built-in tools: plan, memory, widget, finish, skills, meta, remote, knowledge, artifact, agent |
 
 ```typescript
 import {

package/dist/api/tasks.d.ts

@@ -1,6 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
-import { TaskDTO as Task, TaskLogsDTO, TaskTimingsDTO, ApiAppRunRequest, CursorListRequest, CursorListResponse } from '../types';
+import { TaskDTO as Task, TaskLogsDTO, TaskTimingsDTO, ApiAppRunRequest, TaskResultDTO, CursorListRequest, CursorListResponse } from '../types';
 /** How to follow a task while it runs; see TasksAPI.watch. */
 export interface WatchOptions {
     /** Callback for real-time status updates */
@@ -44,9 +44,11 @@ export declare class TasksAPI {
      */
     get(taskId: string): Promise<Response<Task>>;
     /**
-     * Create and run a task
+     * Create and run a task. POST /apps/run answers with the task result
+     * (id, status, output, and the socket for a stream function), not the
+     * full task; `get` fetches that.
      */
-    create(data: ApiAppRunRequest): Promise<Response<Task>>;
+    create(data: ApiAppRunRequest): Promise<Response<TaskResultDTO>>;
     /**
      * Delete a task
      */

package/dist/api/tasks.js

@@ -42,7 +42,9 @@ export class TasksAPI {
         return this.http.request('get', `/tasks/${taskId}`);
     }
     /**
-     * Create and run a task
+     * Create and run a task. POST /apps/run answers with the task result
+     * (id, status, output, and the socket for a stream function), not the
+     * full task; `get` fetches that.
      */
     async create(data) {
         return this.http.request('post', '/apps/run', { data });
@@ -70,18 +72,14 @@ export class TasksAPI {
      */
     async run(params, processedInput, options = {}) {
         const { wait = true } = options;
-        const resp = await this.http.request('post', '/apps/run', {
-            data: {
-                ...params,
-                input: processedInput,
-            },
-        });
-        const task = resp.data;
-        // Return immediately if not waiting
+        const { data: created } = await this.create({ ...params, input: processedInput });
+        // POST /apps/run answers with a TaskResultDTO, not the full task:
+        // fetch that when returning now, or let the watch fill it in.
         if (!wait) {
+            const { data: task } = await this.get(created.id);
             return stripTask(task);
         }
-        return this.watch(task, options).done;
+        return this.watch(created, options).done;
     }
     /**
      * Follows a task until it ends. `done` resolves with the task when it

package/dist/api/teams.d.ts

@@ -1,10 +1,6 @@
 import { HttpClient } from '../http/client';
 import type { Response } from '../http/response';
-import { UserDTO, TeamRelationDTO, TeamMemberDTO, TeamInviteDTO, TeamCreateRequest, TeamMemberAddRequest, TeamInviteCreateRequest, AvailabilityResponse } from '../types';
-export interface MeResponse {
-    user: UserDTO;
-    team?: TeamRelationDTO;
-}
+import { MeResponse, TeamDTO, TeamMemberDTO, TeamInviteDTO, TeamCreateRequest, TeamMemberAddRequest, TeamInviteCreateRequest, AvailabilityResponse } from '../types';
 /**
  * Teams API
  */
@@ -18,19 +14,19 @@ export declare class TeamsAPI {
     /**
      * List user's teams
      */
-    list(): Promise<Response<TeamRelationDTO[]>>;
+    list(): Promise<Response<TeamDTO[]>>;
     /**
      * Get a team by ID
      */
-    get(teamId: string): Promise<Response<TeamRelationDTO>>;
+    get(teamId: string): Promise<Response<TeamDTO>>;
     /**
      * Create a new team
      */
-    create(data: TeamCreateRequest): Promise<Response<TeamRelationDTO>>;
+    create(data: TeamCreateRequest): Promise<Response<TeamDTO>>;
     /**
      * Update a team
      */
-    update(teamId: string, data: Partial<TeamCreateRequest>): Promise<Response<TeamRelationDTO>>;
+    update(teamId: string, data: Partial<TeamCreateRequest>): Promise<Response<TeamDTO>>;
     /**
      * Delete a team
      */

package/dist/index.d.ts

@@ -17,7 +17,7 @@ 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 { TeamsAPI } from './api/teams';
 export { SecretsAPI } from './api/secrets';
 export { ApiKeysAPI } from './api/api-keys';
 export { CredentialsAPI } from './api/credentials';

package/dist/tool-builder.d.ts

@@ -136,6 +136,14 @@ declare class InternalToolsBuilder {
     meta(enabled?: boolean): this;
     /** Enable remote tools (run commands on the user's connected remotes) */
     remote(enabled?: boolean): this;
+    /** Enable knowledge tools (search, read and save the user's skills and knowledge entries) */
+    knowledge(enabled?: boolean): this;
+    /** Enable skill_get for the skills configured on the agent (on by default) */
+    skills(enabled?: boolean): this;
+    /** Enable artifact tools (publish shareable HTML/Markdown pages) */
+    artifact(enabled?: boolean): this;
+    /** Enable the agent tool (run a copy of this agent on a side task) */
+    agent(enabled?: boolean): this;
     /** Enable all internal tools */
     all(): this;
     /** Disable all internal tools */

package/dist/tool-builder.js

@@ -293,6 +293,26 @@ class InternalToolsBuilder {
         this.config.remote = enabled;
         return this;
     }
+    /** Enable knowledge tools (search, read and save the user's skills and knowledge entries) */
+    knowledge(enabled = true) {
+        this.config.knowledge = enabled;
+        return this;
+    }
+    /** Enable skill_get for the skills configured on the agent (on by default) */
+    skills(enabled = true) {
+        this.config.skills = enabled;
+        return this;
+    }
+    /** Enable artifact tools (publish shareable HTML/Markdown pages) */
+    artifact(enabled = true) {
+        this.config.artifact = enabled;
+        return this;
+    }
+    /** Enable the agent tool (run a copy of this agent on a side task) */
+    agent(enabled = true) {
+        this.config.agent = enabled;
+        return this;
+    }
     /** Enable all internal tools */
     all() {
         this.config.plan = true;

package/dist/types.d.ts

@@ -10,8 +10,9 @@ export interface InternalToolsConfig {
     host_context?: boolean;
     meta?: boolean;
     artifact?: boolean;
-    spawn?: boolean;
+    agent?: boolean;
     remote?: boolean;
+    knowledge?: boolean;
 }
 /**
  * AgentTool represents a unified tool that can be used by an agent
@@ -84,6 +85,13 @@ export interface AppToolConfig {
     session_enabled?: boolean;
     setup?: any;
     input?: any;
+    /**
+     * FixedInput pins arguments: they are merged over whatever the model sent,
+     * and removed from the tool schema the model is shown, so it neither sees
+     * nor controls them. Input only supplies defaults the model may override;
+     * this is for values an operator decides, not the model.
+     */
+    fixed_input?: any;
 }
 export interface AgentToolConfig {
     ref: string;
@@ -153,6 +161,7 @@ export interface AppToolConfigDTO {
     session_enabled?: boolean;
     setup?: any;
     input?: any;
+    fixed_input?: any;
 }
 export interface AgentToolConfigDTO {
     ref: string;
@@ -524,6 +533,22 @@ export interface DeviceAuthPollResponse {
     session_token?: string;
     team_id?: string;
 }
+export interface MeResponse {
+    user?: UserDTO;
+    team?: TeamDTO;
+    /**
+     * Org of the current team, when the team belongs to one. Team.Role and
+     * Org.IsAdmin are left unset: what the caller may do is TeamView.Can
+     * and TeamView.Org.Can.
+     */
+    org?: OrgDTO;
+    /**
+     * TeamView is the current team as the caller sees it in settings: kind,
+     * governance and capabilities (GET /teams/{id}/view).
+     */
+    team_view?: TeamViewDTO;
+    diagnostics?: DiagnosticsConfig;
+}
 export interface TeamCreateRequest {
     name: string;
     username: string;
@@ -2936,6 +2961,20 @@ export interface UpdateNotificationPreferencesRequest {
     quiet_hours_end?: string;
     timezone?: string;
 }
+/**
+ * OrgDTO is the API response for an org (enterprise layer above teams).
+ */
+export interface OrgDTO extends BaseModelDTO {
+    slug: string;
+    name: string;
+    avatar_url?: string;
+    default_team_id?: string;
+    /**
+     * IsAdmin: whether the CALLER is on this org's admin grant list. Set on
+     * caller-scoped responses.
+     */
+    is_admin?: boolean;
+}
 /**
  * PageMetadata holds metadata for a page
  */
@@ -3120,6 +3159,9 @@ export interface ProjectDTO extends BaseModelDTO, PermissionModelDTO {
     parent?: ProjectDTO;
     children: (ProjectDTO | undefined)[];
 }
+export interface DiagnosticsConfig {
+    level: number;
+}
 /**
  * RefRouteDTO for API responses
  */
@@ -3714,6 +3756,34 @@ export interface TaskTimingsDTO {
     groups: TaskTimingGroup[];
     events: TaskTimingEvent[];
 }
+/**
+ * TeamDTO is the API response for a full team.
+ */
+export interface TeamDTO extends BaseModelDTO {
+    type: TeamType;
+    name: string;
+    username: string;
+    avatar_url: string;
+    email: string;
+    setup_completed: boolean;
+    max_concurrency: number;
+    status: TeamStatus;
+    /**
+     * Role is the CALLER's role on this team (owner/admin/member), set on
+     * caller-scoped responses (/teams, /users/me). Empty when not applicable
+     * (public team views, platform-admin impersonation).
+     */
+    role?: TeamRole;
+    /**
+     * OrgID of the org this team belongs to ('' = standalone team).
+     */
+    org_id?: 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.
  */
@@ -3775,6 +3845,48 @@ export interface TeamInviteCreateRequest {
     email: string;
     role: TeamRole;
 }
+/**
+ * GovernanceSource says who decides one aspect of a team. By is
+ * shared.GovernedBySelf (the team itself) or shared.GovernedByOrg; TeamID is
+ * the deciding team: the team itself, or the org's workspace.
+ */
+export interface GovernanceSource {
+    by: string;
+    team_id: string;
+}
+/**
+ * TeamGovernance is who decides a team's billing and usage policy.
+ */
+export interface TeamGovernance {
+    billing: GovernanceSource;
+    policy: GovernanceSource;
+}
+/**
+ * TeamViewOrg is the org a team belongs to, as the caller sees it.
+ */
+export interface TeamViewOrg {
+    id: string;
+    name: string;
+    slug: string;
+    avatar_url: string;
+    /**
+     * Can is what the caller may do on the org's workspace, by the same
+     * table as TeamViewDTO.Can: the org's settings and billing live there.
+     */
+    can: TeamCapability[];
+}
+/**
+ * TeamViewDTO is a team as the caller sees it in settings: what kind of
+ * workspace it is, who governs it, and what the caller may do there. Can is computed by the same table the API's route
+ * gates evaluate, so clients read permissions instead of re-deriving them.
+ */
+export interface TeamViewDTO {
+    team_id: string;
+    kind: TeamKind;
+    org?: TeamViewOrg;
+    governance: TeamGovernance;
+    can: TeamCapability[];
+}
 export interface TelemetryReportDTO extends BaseModelDTO, PermissionModelDTO {
     ip: string;
     level: number;
@@ -4161,7 +4273,7 @@ export declare const PlanStepStatusPending: PlanStepStatus;
 export declare const PlanStepStatusInProgress: PlanStepStatus;
 export declare const PlanStepStatusCompleted: PlanStepStatus;
 export declare const PlanStepStatusCancelled: PlanStepStatus;
-export type ChatMessageRole = "system" | "user" | "assistant" | "tool" | "injection" | "compaction";
+export type ChatMessageRole = "system" | "user" | "assistant" | "tool" | "injection" | "compaction" | "event";
 /**
  * LLM wire-protocol roles
  */
@@ -4172,22 +4284,25 @@ export declare const ChatMessageRoleTool: ChatMessageRole;
 /**
  * Internal bookkeeping roles — never sent to the LLM provider.
  * BuildContext folds injections into the user turn and replaces
- * compaction markers with their summary.
+ * compaction markers with their summary. Event messages are display-only
+ * system info (a hook ran, ...) and BuildContext skips them.
  */
 export declare const ChatMessageRoleInjection: ChatMessageRole;
 export declare const ChatMessageRoleCompaction: ChatMessageRole;
+export declare const ChatMessageRoleEvent: ChatMessageRole;
 export type ChatMessageStatus = "pending" | "queued" | "ready" | "failed" | "cancelled";
 export declare const ChatMessageStatusPending: ChatMessageStatus;
 export declare const ChatMessageStatusQueued: ChatMessageStatus;
 export declare const ChatMessageStatusReady: ChatMessageStatus;
 export declare const ChatMessageStatusFailed: ChatMessageStatus;
 export declare const ChatMessageStatusCancelled: ChatMessageStatus;
-export type ChatMessageContentType = "text" | "reasoning" | "image" | "file" | "tool";
+export type ChatMessageContentType = "text" | "reasoning" | "image" | "file" | "tool" | "event";
 export declare const ChatMessageContentTypeText: ChatMessageContentType;
 export declare const ChatMessageContentTypeReasoning: ChatMessageContentType;
 export declare const ChatMessageContentTypeImage: ChatMessageContentType;
 export declare const ChatMessageContentTypeFile: ChatMessageContentType;
 export declare const ChatMessageContentTypeTool: ChatMessageContentType;
+export declare const ChatMessageContentTypeEvent: ChatMessageContentType;
 export type ChannelType = "slack" | "discord" | "teams" | "telegram";
 export declare const ChannelTypeSlack: ChannelType;
 export declare const ChannelTypeDiscord: ChannelType;
@@ -4221,6 +4336,34 @@ export interface ChatMessageContent {
     image?: string;
     file?: string;
     tool_calls?: ToolCall[];
+    event?: ChatEvent;
+}
+export type ChatEventType = "hook";
+export declare const ChatEventTypeHook: ChatEventType;
+/**
+ * ChatEvent is the payload of an event-role message: system info shown in the
+ * chat but never sent to the model.
+ */
+export interface ChatEvent {
+    type: ChatEventType;
+    hook?: ChatHookEvent;
+}
+/**
+ * ChatHookEvent records one lifecycle hook handler run.
+ */
+export interface ChatHookEvent {
+    event: HookEvent;
+    handler_type: HookHandlerType;
+    /**
+     * Handler names what ran: the builtin or agent ref, or a webhook's host
+     * (never its full URL, which can carry credentials).
+     */
+    handler: string;
+    decision?: HookDecision;
+    reason?: string;
+    injected?: boolean;
+    error?: string;
+    duration_ms: number;
 }
 /**
  * ChannelContext records which channel a chat or message came through
@@ -5134,6 +5277,29 @@ export type TeamRole = "owner" | "admin" | "member";
 export declare const TeamRoleOwner: TeamRole;
 export declare const TeamRoleAdmin: TeamRole;
 export declare const TeamRoleMember: TeamRole;
+/**
+ * TeamKind is what a team is from the caller's side of settings: the team
+ * type plus whether it sits inside an org. Capabilities and governance key
+ * on it (see team.Subject).
+ */
+export type TeamKind = "personal" | "team" | "org_member" | "org";
+/**
+ * TeamKindPersonal is an account's own workspace.
+ */
+export declare const TeamKindPersonal: TeamKind;
+/**
+ * TeamKindTeam is a shared workspace outside any org.
+ */
+export declare const TeamKindTeam: TeamKind;
+/**
+ * TeamKindOrgMember is a shared workspace inside an org: billed by the
+ * org and governed by the org's usage policy.
+ */
+export declare const TeamKindOrgMember: TeamKind;
+/**
+ * TeamKindOrg is an org's own workspace (TeamTypeOrg).
+ */
+export declare const TeamKindOrg: TeamKind;
 /**
  * TeamCapability is one thing a caller may do to a team's settings. The set is
  * closed; team.Subject.Can is the only place that grants them.

package/dist/types.js

@@ -575,10 +575,12 @@ export const ChatMessageRoleTool = "tool";
 /**
  * Internal bookkeeping roles — never sent to the LLM provider.
  * BuildContext folds injections into the user turn and replaces
- * compaction markers with their summary.
+ * compaction markers with their summary. Event messages are display-only
+ * system info (a hook ran, ...) and BuildContext skips them.
  */
 export const ChatMessageRoleInjection = "injection";
 export const ChatMessageRoleCompaction = "compaction";
+export const ChatMessageRoleEvent = "event";
 export const ChatMessageStatusPending = "pending";
 export const ChatMessageStatusQueued = "queued";
 export const ChatMessageStatusReady = "ready";
@@ -589,10 +591,12 @@ export const ChatMessageContentTypeReasoning = "reasoning";
 export const ChatMessageContentTypeImage = "image";
 export const ChatMessageContentTypeFile = "file";
 export const ChatMessageContentTypeTool = "tool";
+export const ChatMessageContentTypeEvent = "event";
 export const ChannelTypeSlack = "slack";
 export const ChannelTypeDiscord = "discord";
 export const ChannelTypeTeams = "teams";
 export const ChannelTypeTelegram = "telegram";
+export const ChatEventTypeHook = "hook";
 export const EngineStatusRunning = "running";
 export const EngineStatusPending = "pending";
 export const EngineStatusDraining = "draining";
@@ -1069,6 +1073,23 @@ export const TeamStatusTerminated = "terminated";
 export const TeamRoleOwner = "owner";
 export const TeamRoleAdmin = "admin";
 export const TeamRoleMember = "member";
+/**
+ * TeamKindPersonal is an account's own workspace.
+ */
+export const TeamKindPersonal = "personal";
+/**
+ * TeamKindTeam is a shared workspace outside any org.
+ */
+export const TeamKindTeam = "team";
+/**
+ * TeamKindOrgMember is a shared workspace inside an org: billed by the
+ * org and governed by the org's usage policy.
+ */
+export const TeamKindOrgMember = "org_member";
+/**
+ * TeamKindOrg is an org's own workspace (TeamTypeOrg).
+ */
+export const TeamKindOrg = "org";
 export const TeamCapabilityEditProfile = "edit_profile";
 export const TeamCapabilityManageMembers = "manage_members";
 export const TeamCapabilityViewMembers = "view_members";

package/package.json

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