@agent-api/sdk 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -1,11 +1,25 @@
 # Changelog — @agent-api/sdk
 
+## 1.0.5
+
+### Added
+
+- Main/dev skill branch support and model-facing skill operations for progressive discover, focus, and update workflows.
+
+## 1.0.4
+
+### Added
+
+- `preferred_sites` create-run parameter (up to 3 hostnames) to bias web search and fetch toward specific domains when allowed tools include `web_search` or `web_fetch`.
+- Skill APIs via `client.skills`, create-run `skills` / `local_skills` parameters, and `localSkillFromDirectory()` for SDK-local skill descriptors.
+
 ## 1.0.3
 
 ### Added
 
 - Workbench volume APIs: `summarize`, `grep`, `readLines`, `patchLines`, `downloadArchive`.
 - `responses.retrieveVolume` for `GET /v1/responses/{response_id}/volume`.
+- Create-run params `model_routing` (`auto` | `chain`) and `routing_strategy` (`balanced` | `high-quality` | `cost-effective`) for platform model selection when `model_routing` is `auto`.
 
 ### Changed
 

package/README.md

@@ -2,7 +2,7 @@
 
 Production JavaScript/TypeScript SDK for the Managed Agent API.
 
-**Published on npm:** [`@agent-api/sdk`](https://www.npmjs.com/package/@agent-api/sdk) (v1.0.2)
+**Published on npm:** [`@agent-api/sdk`](https://www.npmjs.com/package/@agent-api/sdk) (v1.0.5)
 
 ## Install
 
@@ -46,7 +46,7 @@ src/
   errors.ts           # Typed error hierarchy + retry helpers
   pagination.ts       # Cursor pagination utilities
   streaming.ts        # SSE parser
-  resources/          # responses, models, presets, tools, volumes
+  resources/          # responses, models, presets, tools, volumes, skills
   types/              # Request/response TypeScript types
   internal/http.ts    # Retries, timeouts, User-Agent
 ```
@@ -60,6 +60,7 @@ src/
 | `client.presets` | `list` |
 | `client.tools` | `list` |
 | `client.volumes` | `list`, `create`, `retrieve`, `update`, `delete`, `listEntries`, `searchEntries`, `readFile`, `writeFile`, `deletePath`, `reconcileUsage`, `createDirectory`, `downloadArchive`, `summarize`, `readLines`, `patchLines`, `grep` |
+| `client.skills` | `list`, `create`, `discover`, `focus`, `createDev`, `updateFile`, `retrieve`, `update`, `archive`, `delete`, `acceptDev`, `discardDev`, `listFiles`, `readFile`, `writeFile`, `deleteFile` |
 
 ## Durable Volumes
 
@@ -77,6 +78,22 @@ const response = await client.agent.create({
 });
 ```
 
+## Skills
+
+```typescript
+import { localSkillFromDirectory } from "@agent-api/sdk";
+
+const skill = await client.skills.create({ name: "research-helper" });
+await client.skills.writeFile(skill.skill_id, "SKILL.md", "# Research helper\n");
+
+const localSkill = await localSkillFromDirectory("./skills/research-helper");
+const response = await client.responses.create({
+  input: "Use the research helper.",
+  skills: [{ skill_id: skill.skill_id, branch: "main" }],
+  local_skills: [localSkill],
+});
+```
+
 ## Production features
 
 - **Retries:** automatic exponential backoff for network failures, 429, and 5xx (default 2 retries).
@@ -106,6 +123,21 @@ for await (const event of stream) {
 }
 ```
 
+## Model routing
+
+Use `model_routing: "auto"` to let the platform pick a model (openmark). Optionally constrain the pool with `models`, and tune selection with `routing_strategy`:
+
+```typescript
+const response = await client.responses.create({
+  input: "Compare two cloud providers for ML workloads.",
+  model_routing: "auto",
+  routing_strategy: "cost-effective",
+  models: ["openai/gpt-5.4", "google/gemini-3-flash-preview"],
+});
+```
+
+Use model ids in vendor/model form (values from `client.models.list()`). Omit `model_routing` (or set `"chain"`) for strict fallback order via `model` / `models`. `routing_strategy` is only valid when `model_routing` is `"auto"`.
+
 ## Client options
 
 ```typescript
@@ -129,6 +161,6 @@ AGENT_API_INTEGRATION=1 AGENT_API_KEY=sk-... AGENT_API_BASE_URL=https://api.agen
 
 ## Scope
 
-The SDK covers the public agent/Responses API, durable volume APIs, and discovery
+The SDK covers the public agent/Responses API, durable volume APIs, skill APIs, and discovery
 endpoints. Console auth, workspace administration, and internal audit records
 are intentionally out of scope.

package/dist/client.d.ts

@@ -1,6 +1,7 @@
 import { ModelsResource } from "./resources/models.js";
 import { PresetsResource } from "./resources/presets.js";
 import { ResponsesResource } from "./resources/responses.js";
+import { SkillsResource } from "./resources/skills.js";
 import { ToolsResource } from "./resources/tools.js";
 import { VolumesResource } from "./resources/volumes.js";
 import type { ClientOptions } from "./types/common.js";
@@ -21,6 +22,7 @@ export declare class AgentAPI {
     readonly presets: PresetsResource;
     readonly tools: ToolsResource;
     readonly volumes: VolumesResource;
+    readonly skills: SkillsResource;
     private readonly http;
     constructor(options?: ClientOptions);
 }

package/dist/client.js

@@ -4,6 +4,7 @@ import { HTTPClient } from "./internal/http.js";
 import { ModelsResource } from "./resources/models.js";
 import { PresetsResource } from "./resources/presets.js";
 import { ResponsesResource } from "./resources/responses.js";
+import { SkillsResource } from "./resources/skills.js";
 import { ToolsResource } from "./resources/tools.js";
 import { VolumesResource } from "./resources/volumes.js";
 import { VERSION } from "./version.js";
@@ -23,6 +24,7 @@ export class AgentAPI {
     presets;
     tools;
     volumes;
+    skills;
     http;
     constructor(options = {}) {
         this.apiKey = options.apiKey ?? readEnv("AGENT_API_KEY");
@@ -50,6 +52,7 @@ export class AgentAPI {
         this.presets = new PresetsResource(this.http);
         this.tools = new ToolsResource(this.http);
         this.volumes = new VolumesResource(this.http);
+        this.skills = new SkillsResource(this.http);
     }
 }
 export { VERSION };

package/dist/index.d.ts

@@ -5,3 +5,5 @@ export { APIError, APIConnectionError, APIStatusError, AuthenticationError, BadR
 export * from "./types/index.js";
 export { functionCallOutputInput, pendingFunctionCalls, runLocalFunctionHandlers, } from "./local-functions.js";
 export type { LocalFunctionHandler, LocalFunctionHandlers } from "./local-functions.js";
+export { localSkillFromDirectory, pendingLocalSkillCalls, runLocalSkillHandlers } from "./local-skills.js";
+export type { LocalSkillDirectoryOptions } from "./local-skills.js";

package/dist/index.js

@@ -3,3 +3,4 @@ export { Page, collectPage } from "./pagination.js";
 export { APIError, APIConnectionError, APIStatusError, AuthenticationError, BadRequestError, InternalServerError, NotFoundError, PermissionDeniedError, RateLimitError, isRetryableStatus, parseResponseError, } from "./errors.js";
 export * from "./types/index.js";
 export { functionCallOutputInput, pendingFunctionCalls, runLocalFunctionHandlers, } from "./local-functions.js";
+export { localSkillFromDirectory, pendingLocalSkillCalls, runLocalSkillHandlers } from "./local-skills.js";

package/dist/local-skills.d.ts

@@ -0,0 +1,12 @@
+import type { LocalSkillDescriptor } from "./types/skills.js";
+import type { FunctionCallOutputInput } from "./types/input.js";
+import type { AgentResponse, FunctionCallOutputItem } from "./types/responses.js";
+export interface LocalSkillDirectoryOptions {
+    id?: string;
+    name?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function localSkillFromDirectory(rootDir: string, options?: LocalSkillDirectoryOptions): Promise<LocalSkillDescriptor>;
+export declare function pendingLocalSkillCalls(response: AgentResponse): FunctionCallOutputItem[];
+export declare function runLocalSkillHandlers(response: AgentResponse, localSkills: LocalSkillDescriptor[]): Promise<FunctionCallOutputInput[]>;

package/dist/local-skills.js

@@ -0,0 +1,140 @@
+import { functionCallOutputInput, pendingFunctionCalls } from "./local-functions.js";
+export async function localSkillFromDirectory(rootDir, options = {}) {
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    const crypto = await import("node:crypto");
+    const root = path.resolve(rootDir);
+    const files = await walkFiles(fs, path, root, root);
+    const hash = crypto.createHash("sha256");
+    for (const rel of files.sort()) {
+        hash.update(rel);
+        hash.update("\0");
+        hash.update(await fs.readFile(path.join(root, rel)));
+        hash.update("\0");
+    }
+    const digest = "sha256:" + hash.digest("hex");
+    const base = path.basename(root);
+    return {
+        local_skill_id: options.id ?? base,
+        name: options.name ?? base,
+        description: options.description,
+        root_hint: root,
+        digest,
+        metadata: options.metadata,
+    };
+}
+export function pendingLocalSkillCalls(response) {
+    return pendingFunctionCalls(response).filter((call) => call.name === "skill_focus");
+}
+export async function runLocalSkillHandlers(response, localSkills) {
+    const byID = new Map(localSkills.map((skill) => [skill.local_skill_id, skill]));
+    const outputs = [];
+    for (const call of pendingLocalSkillCalls(response)) {
+        const args = call.arguments ? JSON.parse(call.arguments) : {};
+        const payload = await focusLocalSkills(args, byID);
+        outputs.push(functionCallOutputInput(call.call_id, payload));
+    }
+    return outputs;
+}
+async function focusLocalSkills(args, byID) {
+    const maxManifestBytes = Number(args.max_manifest_bytes || 16 * 1024);
+    const items = Array.isArray(args.skills) ? args.skills : [];
+    if (!Array.isArray(args.skills)) {
+        return { data: [{ ok: false, error: { code: "invalid_skill_focus", message: "skills must be an array" } }] };
+    }
+    const data = [];
+    for (const raw of items) {
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            data.push({ ok: false, error: { code: "invalid_skill_focus", message: "skill item must be an object" } });
+            continue;
+        }
+        const item = raw;
+        const localSkillID = String(item.local_skill_id || "").trim();
+        const result = { ok: false, local_skill_id: localSkillID, branch: "main" };
+        const descriptor = byID.get(localSkillID);
+        if (!descriptor) {
+            result.error = { code: "local_skill_not_found", message: "local_skill_id was not registered with the SDK" };
+            data.push(result);
+            continue;
+        }
+        try {
+            result.skill = await focusedLocalSkill(descriptor, maxManifestBytes);
+            result.ok = true;
+        }
+        catch (error) {
+            result.error = { code: "local_skill_focus_failed", message: error instanceof Error ? error.message : String(error) };
+        }
+        data.push(result);
+    }
+    return { data };
+}
+async function focusedLocalSkill(descriptor, maxManifestBytes) {
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    const root = path.resolve(descriptor.root_hint || ".");
+    const stat = await fs.stat(root);
+    if (!stat.isDirectory()) {
+        throw new Error(`local skill root is not a directory: ${root}`);
+    }
+    let manifest = "";
+    let manifestTruncated = false;
+    try {
+        let manifestBytes = await fs.readFile(path.join(root, "SKILL.md"));
+        if (maxManifestBytes > 0 && manifestBytes.length > maxManifestBytes) {
+            manifestBytes = manifestBytes.subarray(0, maxManifestBytes);
+            manifestTruncated = true;
+        }
+        manifest = manifestBytes.toString("utf8");
+    }
+    catch (error) {
+        if (error?.code !== "ENOENT") {
+            throw error;
+        }
+    }
+    const dirents = await fs.readdir(root, { withFileTypes: true });
+    const entries = await Promise.all(dirents
+        .filter((entry) => ![".git", "__pycache__", "node_modules"].includes(entry.name))
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map(async (entry) => {
+        const full = path.join(root, entry.name);
+        const entryStat = await fs.stat(full);
+        return {
+            path: entry.name,
+            is_dir: entry.isDirectory(),
+            size: entry.isDirectory() ? 0 : entryStat.size,
+            modified_at: Math.floor(entryStat.mtimeMs / 1000),
+        };
+    }));
+    return {
+        source_type: "SKILL_SOURCE_TYPE_LOCAL",
+        local_skill_id: descriptor.local_skill_id,
+        name: descriptor.name || "",
+        description: descriptor.description || "",
+        branch: "SKILL_BRANCH_MAIN",
+        digest: descriptor.digest || "",
+        artifact_uri: "local://" + root.replace(/^\/+/, ""),
+        mount_hint: root,
+        manifest,
+        manifest_truncated: manifestTruncated,
+        entries,
+        metadata: descriptor.metadata || {},
+    };
+}
+async function walkFiles(fs, path, root, dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const out = [];
+    for (const entry of entries) {
+        if (entry.name === ".git" || entry.name === "node_modules") {
+            continue;
+        }
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            out.push(...await walkFiles(fs, path, root, full));
+            continue;
+        }
+        if (entry.isFile()) {
+            out.push(path.relative(root, full).split(path.sep).join("/"));
+        }
+    }
+    return out;
+}

package/dist/resources/skills.d.ts

@@ -0,0 +1,33 @@
+import type { HTTPClient } from "../internal/http.js";
+import type { RequestOptions } from "../types/common.js";
+import type { CreateSkillParams, CreateSkillDevParams, CreateSkillDevResponse, DiscoverSkillsParams, FocusSkillParams, ListSkillFilesParams, ListSkillFilesResponse, ListSkillsParams, ListSkillsResponse, ListSkillSummariesResponse, Skill, SkillFile, SkillBranch, SkillFocusResponse, UpdateSkillFilePrimitiveParams, UpdateSkillFilePrimitiveResponse, UpdateSkillParams } from "../types/skills.js";
+export declare class SkillsResource {
+    private readonly http;
+    constructor(http: HTTPClient);
+    list(params?: ListSkillsParams, options?: RequestOptions): Promise<ListSkillsResponse>;
+    create(params?: CreateSkillParams, options?: RequestOptions): Promise<Skill>;
+    discover(params?: DiscoverSkillsParams, options?: RequestOptions): Promise<ListSkillSummariesResponse>;
+    focus(params: FocusSkillParams, options?: RequestOptions): Promise<SkillFocusResponse>;
+    createDev(params: CreateSkillDevParams, options?: RequestOptions): Promise<CreateSkillDevResponse>;
+    updateFile(params: UpdateSkillFilePrimitiveParams, options?: RequestOptions): Promise<UpdateSkillFilePrimitiveResponse>;
+    retrieve(skillID: string, options?: RequestOptions): Promise<Skill>;
+    update(skillID: string, params: UpdateSkillParams, options?: RequestOptions): Promise<Skill>;
+    archive(skillID: string, options?: RequestOptions): Promise<Skill>;
+    delete(skillID: string, options?: RequestOptions): Promise<{
+        deleted: boolean;
+    }>;
+    acceptDev(skillID: string, options?: RequestOptions): Promise<Skill>;
+    discardDev(skillID: string, options?: RequestOptions): Promise<Skill>;
+    listFiles(skillID: string, params?: ListSkillFilesParams, options?: RequestOptions): Promise<ListSkillFilesResponse>;
+    readFile(skillID: string, path: string, params?: {
+        branch?: SkillBranch;
+        fallback_to_main?: boolean;
+        max_bytes?: number;
+    }, options?: RequestOptions): Promise<SkillFile>;
+    writeFile(skillID: string, path: string, content: string | ArrayBuffer | Blob, params?: {
+        branch?: SkillBranch;
+    }, options?: RequestOptions): Promise<SkillFile>;
+    deleteFile(skillID: string, path: string, params?: {
+        branch?: SkillBranch;
+    }, options?: RequestOptions): Promise<SkillFile>;
+}

package/dist/resources/skills.js

@@ -0,0 +1,76 @@
+import { buildQuery } from "../internal/query.js";
+export class SkillsResource {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    list(params = {}, options) {
+        return this.http.request("GET", `/v1/skills${buildQuery({
+            include_archived: params.include_archived ? "true" : undefined,
+            limit: params.limit,
+            page_token: params.page_token,
+        })}`, undefined, options);
+    }
+    create(params = {}, options) {
+        return this.http.request("POST", "/v1/skills", params, options);
+    }
+    discover(params = {}, options) {
+        return this.http.request("POST", "/v1/skills/discover", params, options);
+    }
+    focus(params, options) {
+        return this.http.request("POST", "/v1/skills/focus", params, options);
+    }
+    createDev(params, options) {
+        return this.http.request("POST", "/v1/skills/create_dev", params, options);
+    }
+    updateFile(params, options) {
+        return this.http.request("POST", "/v1/skills/update_file", params, options);
+    }
+    retrieve(skillID, options) {
+        return this.http.request("GET", `/v1/skills/${encodeURIComponent(skillID)}`, undefined, options);
+    }
+    update(skillID, params, options) {
+        return this.http.request("PATCH", `/v1/skills/${encodeURIComponent(skillID)}`, params, options);
+    }
+    archive(skillID, options) {
+        return this.http.request("POST", `/v1/skills/${encodeURIComponent(skillID)}/archive`, {}, options);
+    }
+    delete(skillID, options) {
+        return this.http.request("DELETE", `/v1/skills/${encodeURIComponent(skillID)}`, undefined, options);
+    }
+    acceptDev(skillID, options) {
+        return this.http.request("POST", `/v1/skills/${encodeURIComponent(skillID)}/accept_dev`, {}, options);
+    }
+    discardDev(skillID, options) {
+        return this.http.request("POST", `/v1/skills/${encodeURIComponent(skillID)}/discard_dev`, {}, options);
+    }
+    listFiles(skillID, params = {}, options) {
+        return this.http.request("GET", `/v1/skills/${encodeURIComponent(skillID)}/files${buildQuery({
+            path: params.path,
+            branch: params.branch,
+            fallback_to_main: params.fallback_to_main === false ? "false" : undefined,
+            limit: params.limit,
+            page_token: params.page_token,
+        })}`, undefined, options);
+    }
+    readFile(skillID, path, params = {}, options) {
+        return this.http.request("GET", `/v1/skills/${encodeURIComponent(skillID)}/files/${skillPath(path)}${buildQuery({
+            branch: params.branch,
+            fallback_to_main: params.fallback_to_main === false ? "false" : undefined,
+            max_bytes: params.max_bytes,
+        })}`, undefined, options);
+    }
+    writeFile(skillID, path, content, params = {}, options) {
+        return this.http.requestRaw("PUT", `/v1/skills/${encodeURIComponent(skillID)}/files/${skillPath(path)}${buildQuery({ branch: params.branch })}`, content, options);
+    }
+    deleteFile(skillID, path, params = {}, options) {
+        return this.http.request("DELETE", `/v1/skills/${encodeURIComponent(skillID)}/files/${skillPath(path)}${buildQuery({ branch: params.branch })}`, undefined, options);
+    }
+}
+function skillPath(path) {
+    return path
+        .split("/")
+        .filter(Boolean)
+        .map((part) => encodeURIComponent(part))
+        .join("/");
+}

package/dist/types/common.d.ts

@@ -3,6 +3,8 @@ export type JSONValue = JSONPrimitive | JSONValue[] | {
     [key: string]: JSONValue;
 };
 export type AgentCapabilityPreference = "off" | "auto" | "preferred" | "required";
+export type ModelRoutingMode = "auto" | "chain";
+export type ModelRoutingStrategy = "balanced" | "high-quality" | "cost-effective";
 export interface ClientOptions {
     apiKey?: string;
     baseURL?: string;

package/dist/types/index.d.ts

@@ -5,3 +5,4 @@ export * from "./responses.js";
 export * from "./streaming.js";
 export * from "./catalog.js";
 export * from "./volumes.js";
+export * from "./skills.js";

package/dist/types/index.js

@@ -5,3 +5,4 @@ export * from "./responses.js";
 export * from "./streaming.js";
 export * from "./catalog.js";
 export * from "./volumes.js";
+export * from "./skills.js";

package/dist/types/responses.d.ts

@@ -1,5 +1,6 @@
-import type { AgentCapabilityPreference, ErrorInfo, OutputItemStatus, ResponseStatus, Usage } from "./common.js";
+import type { AgentCapabilityPreference, ErrorInfo, ModelRoutingMode, ModelRoutingStrategy, OutputItemStatus, ResponseStatus, Usage } from "./common.js";
 import type { ContentPart, Input, MemoryOptions, ReasoningConfig, ResponseFormat } from "./input.js";
+import type { LocalSkillDescriptor, SkillReference } from "./skills.js";
 import type { Tool } from "./tools.js";
 export interface ResponseCreateParamsBase {
     input: Input;
@@ -7,6 +8,8 @@ export interface ResponseCreateParamsBase {
     language_preference?: string;
     model?: string;
     models?: string[];
+    model_routing?: ModelRoutingMode;
+    routing_strategy?: ModelRoutingStrategy;
     preset?: "fast-search" | "pro-search" | "deep-research" | "advanced-deep-research" | string;
     max_output_tokens?: number;
     max_steps?: number;
@@ -19,6 +22,9 @@ export interface ResponseCreateParamsBase {
     store?: boolean;
     previous_response_id?: string;
     volume_id?: string;
+    preferred_sites?: string[];
+    skills?: SkillReference[];
+    local_skills?: LocalSkillDescriptor[];
     prompt_cache_key?: string;
     memory?: MemoryOptions;
     plan_mode_preference?: AgentCapabilityPreference;

package/dist/types/skills.d.ts

@@ -0,0 +1,176 @@
+export type SkillSourceType = "SKILL_SOURCE_TYPE_PLATFORM" | "SKILL_SOURCE_TYPE_LOCAL" | "SKILL_SOURCE_TYPE_GENERATED" | string;
+export type SkillBranch = "main" | "dev" | string;
+export interface SkillReference {
+    skill_id: string;
+    branch?: SkillBranch;
+}
+export interface LocalSkillDescriptor {
+    local_skill_id: string;
+    name?: string;
+    description?: string;
+    root_hint?: string;
+    digest?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface Skill {
+    object: "skill";
+    skill_id: string;
+    tenant_id?: string;
+    name: string;
+    description?: string;
+    source_type?: SkillSourceType;
+    main_digest?: string;
+    dev_digest?: string;
+    has_dev?: boolean;
+    dev_updated_at?: number;
+    dev_source_response_id?: string;
+    created_by_user_id?: string;
+    updated_by_user_id?: string;
+    created_at?: number;
+    updated_at?: number;
+    metadata?: Record<string, unknown>;
+    archived?: boolean;
+}
+export interface SkillSummary {
+    object: "skill_summary";
+    skill_id: string;
+    name?: string;
+    description?: string;
+    source_type?: SkillSourceType;
+    branch?: SkillBranch;
+    digest?: string;
+    artifact_uri?: string;
+    has_dev?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface FocusedSkill extends Omit<SkillSummary, "object"> {
+    object: "focused_skill";
+    mount_hint?: string;
+    manifest?: string;
+    manifest_truncated?: boolean;
+    entries?: SkillFileEntry[];
+}
+export interface SkillFocusItem {
+    skill_id?: string;
+    branch?: SkillBranch;
+    local_skill?: LocalSkillDescriptor;
+}
+export interface SkillOperationError {
+    code?: string;
+    message?: string;
+}
+export interface SkillFocusResultItem {
+    ok: boolean;
+    skill_id?: string;
+    local_skill_id?: string;
+    branch?: SkillBranch;
+    skill?: FocusedSkill;
+    error?: SkillOperationError;
+}
+export interface SkillFocusResponse {
+    object: "skill_focus_result";
+    data: SkillFocusResultItem[];
+}
+export interface SkillFileEntry {
+    path: string;
+    is_dir: boolean;
+    size: number;
+    modified_at?: number;
+}
+export interface ListSkillsParams {
+    include_archived?: boolean;
+    limit?: number;
+    page_token?: string;
+}
+export interface ListSkillsResponse {
+    object: "list";
+    data: Skill[];
+    next_page_token?: string;
+}
+export interface ListSkillSummariesResponse {
+    object: "list";
+    data: SkillSummary[];
+    next_page_token?: string;
+}
+export interface DiscoverSkillsParams {
+    query?: string;
+    branch?: SkillBranch | "both";
+    include_dev?: boolean;
+    limit?: number;
+    local_skills?: LocalSkillDescriptor[];
+}
+export interface FocusSkillParams {
+    skills: SkillFocusItem[];
+    fallback_to_main?: boolean;
+    max_manifest_bytes?: number;
+}
+export interface SkillFileMutation {
+    path: string;
+    content?: string;
+    content_base64?: string;
+}
+export interface CreateSkillDevParams {
+    name: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+    files?: SkillFileMutation[];
+}
+export interface CreateSkillDevResponse {
+    object: "skill_create_result";
+    skill: Skill;
+    branch: SkillBranch;
+    files: Array<{
+        path: string;
+        size: number;
+    }>;
+    focused_skill?: FocusedSkill;
+}
+export interface SkillFileUpdateMutation extends SkillFileMutation {
+    skill_id: string;
+}
+export interface UpdateSkillFilePrimitiveParams {
+    updates: SkillFileUpdateMutation[];
+}
+export interface SkillUpdateResultItem {
+    ok: boolean;
+    skill_id?: string;
+    path?: string;
+    size?: number;
+    skill?: SkillSummary;
+    error?: SkillOperationError;
+}
+export interface UpdateSkillFilePrimitiveResponse {
+    object: "skill_update_result";
+    data: SkillUpdateResultItem[];
+}
+export interface ListSkillFilesParams {
+    path?: string;
+    branch?: SkillBranch;
+    fallback_to_main?: boolean;
+    limit?: number;
+    page_token?: string;
+}
+export interface ListSkillFilesResponse {
+    object: "list";
+    entries: SkillFileEntry[];
+    next_page_token?: string;
+}
+export interface SkillFile {
+    object: "skill_file";
+    path?: string;
+    branch?: SkillBranch;
+    content?: string;
+    size: number;
+    truncated?: boolean;
+    recursive?: boolean;
+}
+export interface CreateSkillParams {
+    name?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface UpdateSkillParams {
+    name?: string;
+    description?: string;
+    metadata?: Record<string, unknown>;
+}

package/dist/types/skills.js

@@ -0,0 +1 @@
+export {};

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "1.0.3";
-export declare const USER_AGENT = "@agent-api/sdk/1.0.3";
+export declare const VERSION = "1.0.5";
+export declare const USER_AGENT = "@agent-api/sdk/1.0.5";

package/dist/version.js

@@ -1,2 +1,2 @@
-export const VERSION = "1.0.3";
+export const VERSION = "1.0.5";
 export const USER_AGENT = `@agent-api/sdk/${VERSION}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-api/sdk",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Production JavaScript SDK for the Managed Agent API",
   "license": "MIT",
   "repository": {