@vellumai/assistant 0.12.4-staging.2 → 0.12.4-staging.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.12.4-staging.2",
+  "version": "0.12.4-staging.3",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/openai-responses-prompt-cache.test.ts

@@ -446,7 +446,7 @@ describe("OpenAIResponsesProvider explicit prompt caching (GPT-5.6+)", () => {
     expect(JSON.stringify(messages)).not.toContain("prompt_cache_breakpoint");
   });
 
-  test("catalog flags GPT-5.6 and GPT-6 Astra direct-openai rows", () => {
+  test("catalog flags GPT-5.6 and GPT-6 direct-openai rows", () => {
     const openai = PROVIDER_CATALOG.find((p) => p.id === "openai");
     const flagged = (openai?.models ?? [])
       .filter((m) => m.supportsPromptCacheBreakpoints)
@@ -457,6 +457,8 @@ describe("OpenAIResponsesProvider explicit prompt caching (GPT-5.6+)", () => {
       "gpt-5.6-sol",
       "gpt-5.6-terra",
       "gpt-6-astra",
+      "gpt-6-luna",
+      "gpt-6-sol",
     ]);
   });
 });

package/src/__tests__/pricing.test.ts

@@ -135,6 +135,39 @@ describe("resolvePricing", () => {
       expect(result.estimatedCostUsd).toBeCloseTo(0.5 + 0.625 + 0.05, 10);
     });
 
+    test("bills GPT-6 Sol at published short-context rates", () => {
+      const result = resolvePricingForUsage("openai", "gpt-6-sol", {
+        directInputTokens: 50_000,
+        outputTokens: 50_000,
+        cacheCreationInputTokens: 50_000,
+        cacheReadInputTokens: 50_000,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      // 0.05M x $2 direct + 0.05M x $2.5 write + 0.05M x $0.2 read
+      // + 0.05M x $10 output.
+      expect(result.estimatedCostUsd).toBeCloseTo(0.1 + 0.125 + 0.01 + 0.5, 10);
+    });
+
+    test("bills GPT-6 Luna at the long-context tier above 272k", () => {
+      const result = resolvePricingForUsage("openai", "gpt-6-luna", {
+        directInputTokens: 500_000,
+        outputTokens: 1_000_000,
+        cacheCreationInputTokens: 500_000,
+        cacheReadInputTokens: 1_000_000,
+        anthropicCacheCreation: null,
+      });
+
+      expect(result.pricingStatus).toBe("priced");
+      // Tier rates: 0.5M x $0.2 direct + 0.5M x $0.25 write + 1M x $0.02 read
+      // + 1M x $0.75 output.
+      expect(result.estimatedCostUsd).toBeCloseTo(
+        0.1 + 0.125 + 0.02 + 0.75,
+        10,
+      );
+    });
+
     test("bills GPT-6 Astra at the long-context tier above 272k", () => {
       const result = resolvePricingForUsage("openai", "gpt-6-astra", {
         directInputTokens: 500_000,

package/src/__tests__/skill-load-tool.test.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, symlinkSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, symlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
@@ -781,16 +781,48 @@ describe("skill_load tool", () => {
     expect(result.content).toContain("Deploy the application to production");
     expect(result.content).toContain("Rollback to previous version");
 
-    // Should list parameters with types and required/optional markers
-    expect(result.content).toContain(
-      "- environment (string, required): Target environment",
+    const schemas = [
+      ...result.content.matchAll(/```json\n([\s\S]*?)\n```/g),
+    ].map((match) => JSON.parse(match[1]));
+    expect(schemas[0].required).toEqual(["environment"]);
+    expect(schemas[0].properties.environment).toEqual({
+      type: "string",
+      description: "Target environment",
+    });
+    expect(schemas[0].properties.force.type).toBe("boolean");
+    expect(schemas[1].required).toEqual(["version"]);
+  });
+
+  test("discloses the complete annotation mark schema before execution", async () => {
+    const manifest = JSON.parse(
+      readFileSync(
+        join(
+          import.meta.dir,
+          "../config/bundled-skills/screen-annotation/TOOLS.json",
+        ),
+        "utf-8",
+      ),
     );
-    expect(result.content).toContain(
-      "- force (boolean, optional): Force deploy even if checks fail",
+    writeSkill(
+      "annotation-schema",
+      "Annotation Schema",
+      "Point at a control",
+      "Name the control.",
     );
-    expect(result.content).toContain(
-      "- version (string, required): Version to rollback to",
+    writeToolsJson("annotation-schema", manifest.tools);
+
+    const result = await executeSkillLoad(
+      { skill: "annotation-schema" },
+      "macos",
     );
+    expect(result.isError).toBe(false);
+    const schemaMatch = result.content.match(/```json\n([\s\S]*?)\n```/);
+    expect(schemaMatch).not.toBeNull();
+    const schema = JSON.parse(schemaMatch![1]);
+    expect(schema).toEqual(manifest.tools[0].input_schema);
+    expect(schema.properties.marks.items.oneOf).toHaveLength(2);
+    expect(schema.properties.marks.items.properties.target.minLength).toBe(1);
+    expect(schema.properties.marks.items.properties.caption.maxLength).toBe(80);
   });
 
   test("skill without TOOLS.json does not include tool schemas section", async () => {
@@ -862,9 +894,8 @@ describe("skill_load tool", () => {
     // The child skill's tool schemas should appear (#### level under ### Tools from …)
     expect(result.content).toContain("#### child_action");
     expect(result.content).toContain("A child tool action");
-    expect(result.content).toContain(
-      "- target (string, required): Action target",
-    );
+    const schemaMatch = result.content.match(/```json\n([\s\S]*?)\n```/);
+    expect(JSON.parse(schemaMatch![1]).required).toEqual(["target"]);
     expect(result.content).toContain(
       "Use `skill_execute` to call these tools.",
     );

package/src/__tests__/skill-tool-factory.test.ts

@@ -4,7 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterAll, beforeAll, describe, expect, test } from "bun:test";
 
-import type { SkillToolEntry } from "../config/skills.js";
+import { getBundledSkillsDir, type SkillToolEntry } from "../config/skills.js";
 import { RiskLevel } from "../permissions/types.js";
 import { computeSkillVersionHash } from "../skills/version-hash.js";
 import { resolveSubagentRole } from "../subagent/role-resolution.js";
@@ -261,6 +261,54 @@ describe("createSkillTool — unknown parameter validation", () => {
     expect(result.content).toContain('Unknown parameter "bar"');
   });
 
+  test.each([
+    { description: "Filters" },
+    { marks: [{ description: "Filters" }] },
+    { marks: [{}] },
+    { marks: [{ target: 42 }] },
+    { marks: [{ x: 0.1, y: 0.2 }] },
+    { marks: [{ target: "Filters", x: 0.1, y: 0.2, width: 0.3, height: 0.4 }] },
+  ])(
+    "an annotation validation error provides enough schema for one corrected retry: %j",
+    async (invalid) => {
+      const skillDir = join(getBundledSkillsDir(), "screen-annotation");
+      const manifest = JSON.parse(
+        readFileSync(join(skillDir, "TOOLS.json"), "utf-8"),
+      );
+      const entry = manifest.tools.find(
+        (tool: SkillToolEntry) => tool.name === "screen_point_at",
+      );
+      const tool = createSkillTool(
+        entry,
+        skillDir,
+        computeSkillVersionHash(skillDir),
+        BUNDLED,
+      );
+      const calls: unknown[] = [];
+      const context = makeContext({
+        proxyToolResolver: async (name, input) => {
+          calls.push({ name, input });
+          return { content: "Drew 1 mark", isError: false };
+        },
+      });
+
+      const rejected = await tool.execute(invalid, context);
+      expect(rejected.isError).toBe(true);
+      expect(calls).toHaveLength(0);
+      expect(rejected.content).toContain("skill_load");
+      const schemaMatch = rejected.content.match(/```json\n([\s\S]*?)\n```/);
+      expect(schemaMatch).not.toBeNull();
+      expect(JSON.parse(schemaMatch![1])).toEqual(entry.input_schema);
+
+      const input = {
+        marks: [{ target: "Filters", caption: "Click Filters" }],
+      };
+      const corrected = await tool.execute(input, context);
+      expect(corrected.isError).toBe(false);
+      expect(calls).toEqual([{ name: "computer_use_point_at", input }]);
+    },
+  );
+
   test("allows input with only known parameters", async () => {
     const hash = computeSkillVersionHash(tempDir);
     const tool = createSkillTool(
@@ -471,7 +519,7 @@ describe("createSkillTool — required/type/enum validation", () => {
 
     expect(result.isError).toBe(true);
     expect(result.content).toContain(
-      "auto_open must be a boolean — pass true or false as a JSON boolean, not a string",
+      "auto_open must be a boolean: pass true or false as a JSON boolean, not a string",
     );
   });
 

package/src/__tests__/validate-input.test.ts

@@ -6,6 +6,79 @@ import {
   validateInputAgainstSchema,
 } from "../skills/validate-input.js";
 
+describe("nested input validation", () => {
+  const schema = {
+    properties: {
+      options: {
+        type: "object",
+        properties: { label: { type: "string" } },
+        required: ["label"],
+      },
+    },
+  };
+
+  test("reports nested required fields and types with their path", () => {
+    expect(
+      validateInputAgainstSchema("example", { options: {} }, schema),
+    ).toEqual({
+      ok: false,
+      errors: ["options.label is required"],
+    });
+    expect(
+      validateInputAgainstSchema("example", { options: { label: 42 } }, schema),
+    ).toEqual({
+      ok: false,
+      errors: ["options.label must be a string"],
+    });
+  });
+
+  test("preserves open nested objects and only rejects explicitly closed extra fields", () => {
+    const input = { options: { label: "Example", extra: true } };
+    expect(validateInputAgainstSchema("example", input, schema)).toEqual({
+      ok: true,
+    });
+    expect(
+      validateInputAgainstSchema("example", input, {
+        properties: {
+          options: {
+            ...schema.properties.options,
+            additionalProperties: false,
+          },
+        },
+      }),
+    ).toEqual({
+      ok: false,
+      errors: ['Unknown parameter "options.extra". Supported: "label"'],
+    });
+  });
+
+  test("does not treat a richer oneOf as a presence-only union", () => {
+    expect(
+      validateInputAgainstSchema(
+        "example",
+        { options: { label: "Example" } },
+        {
+          properties: {
+            options: {
+              ...schema.properties.options,
+              oneOf: [
+                {
+                  required: ["label"],
+                  properties: { label: { const: "Example" } },
+                },
+                {
+                  required: ["label"],
+                  properties: { label: { const: "Other" } },
+                },
+              ],
+            },
+          },
+        },
+      ),
+    ).toEqual({ ok: true });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // required
 // ---------------------------------------------------------------------------

package/src/plugins/defaults/memory/substrate/skill-content.ts

@@ -34,7 +34,7 @@ export const DEFAULT_CARD_CHARS = 500;
  * only, so a missing product is not evidence it is unsupported.
  */
 export const SKILLS_INJECTION_CATALOG_HINT =
-  "Injected skills are only ones currently in the workspace. Run `assistant plugins search <name>` and `assistant skills search <name>` before concluding a given integration or skill is unsupported";
+  "These skill cards describe availability, not tool instructions. When skill_load is available, use it to load a skill's current instructions and input schemas before calling its tools; follow those schemas over remembered arguments. Injected skills are only ones currently in the workspace. Run `assistant plugins search <name>` and `assistant skills search <name>` before concluding a given integration or skill is unsupported";
 
 /**
  * Render the prose-style capability statement embedded into the unified

package/src/plugins/defaults/memory/v3/__tests__/render-injection.test.ts

@@ -31,6 +31,9 @@ describe("renderInjectionBlockInner", () => {
     expect(inner).toContain("assistant plugins search <name>");
     expect(inner).toContain("assistant skills search <name>");
     expect(inner).toContain("currently in the workspace");
+    expect(inner).toContain("When skill_load is available, use it");
+    expect(inner).toContain("before calling its tools");
+    expect(inner).toContain("over remembered arguments");
     expect(inner.indexOf("# Skills")).toBeLessThan(inner.indexOf("# Skill:"));
     expect(inner.startsWith(`${V3_INJECTION_HEADER}\n\n# Skills\n`)).toBe(true);
   });

package/src/providers/__tests__/connection-model-compat.test.ts

@@ -57,6 +57,8 @@ describe("isConnectionCompatibleWithModel", () => {
   test("oauth_subscription connection is compatible with a Codex model", () => {
     const conn = { auth: oauthAuth };
     expect(isConnectionCompatibleWithModel(conn, "gpt-6-astra")).toBe(true);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-6-sol")).toBe(true);
+    expect(isConnectionCompatibleWithModel(conn, "gpt-6-luna")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-sol")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-terra")).toBe(true);
     expect(isConnectionCompatibleWithModel(conn, "gpt-5.6-luna")).toBe(true);

package/src/providers/anthropic/client.ts

@@ -1004,7 +1004,7 @@ export class AnthropicProvider implements Provider {
       const isHaiku = effectiveModel.includes("haiku");
       // Effort support is per-model: Haiku and Sonnet 4.5 reject the param (see isEffortSupported).
       const supportsEffort = isEffortSupported(effectiveModel);
-      // opus-4-7 / opus-4-8 / opus-5 and sonnet-5 reject `temperature`,
+      // opus-4-7 / opus-4-8 / opus-5 / opus-5-5 and sonnet-5 reject `temperature`,
       // `top_p`, and `top_k` with a 400 "`temperature`/`top_p` is deprecated
       // for this model" — model-wide, not effort-conditional (verified
       // 2026-06-23). opus-4-6 / sonnet-4-6 / haiku-4-5 still accept them.
@@ -1016,7 +1016,7 @@ export class AnthropicProvider implements Provider {
       // suffix is what matches.
       const deprecatesSamplingParams =
         /claude-opus-4-[78]\b/.test(effectiveModel) ||
-        /claude-opus-5\b/.test(effectiveModel) ||
+        /claude-opus-5(-5)?\b/.test(effectiveModel) ||
         /claude-sonnet-5\b/.test(effectiveModel) ||
         /claude-fable-/.test(effectiveModel);
       const mergedOutputConfig = {

package/src/providers/model-catalog.ts

@@ -245,6 +245,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 1,
         },
       },
+      {
+        id: "claude-opus-5-5",
+        displayName: "Claude Opus 5.5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 4,
+          outputPer1mTokens: 20,
+          cacheWritePer1mTokens: 5,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
       {
         id: "claude-opus-5",
         displayName: "Claude Opus 5",
@@ -456,6 +474,66 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           ],
         },
       },
+      {
+        id: "gpt-6-sol",
+        displayName: "GPT-6 Sol",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 10,
+          cacheWritePer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.2,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 4,
+              outputPer1mTokens: 15,
+              cacheWritePer1mTokens: 5,
+              cacheReadPer1mTokens: 0.4,
+            },
+          ],
+        },
+      },
+      {
+        id: "gpt-6-luna",
+        displayName: "GPT-6 Luna",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 0.1,
+          outputPer1mTokens: 0.5,
+          cacheWritePer1mTokens: 0.125,
+          cacheReadPer1mTokens: 0.01,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 0.2,
+              outputPer1mTokens: 0.75,
+              cacheWritePer1mTokens: 0.25,
+              cacheReadPer1mTokens: 0.02,
+            },
+          ],
+        },
+      },
       // GPT-5.6 family (Sol / Terra / Luna). cacheRead is the 90% cached-read
       // discount; cacheWrite is the 1.25x-input rate GPT-5.6+ bills for
       // prompt tokens written to the cache (reported as `cache_write_tokens`
@@ -1209,6 +1287,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 1,
         },
       },
+      {
+        id: "anthropic/claude-opus-5.5",
+        displayName: "Claude Opus 5.5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 4,
+          outputPer1mTokens: 20,
+          cacheWritePer1mTokens: 5,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
       {
         id: "anthropic/claude-opus-5",
         displayName: "Claude Opus 5",
@@ -1431,6 +1527,126 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           ],
         },
       },
+      {
+        id: "openai/gpt-6-sol",
+        displayName: "GPT-6 Sol",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 10,
+          cacheWritePer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.2,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 4,
+              outputPer1mTokens: 15,
+              cacheWritePer1mTokens: 5,
+              cacheReadPer1mTokens: 0.4,
+            },
+          ],
+        },
+      },
+      {
+        id: "openai/gpt-6-sol-pro",
+        displayName: "GPT-6 Sol Pro",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 2,
+          outputPer1mTokens: 10,
+          cacheWritePer1mTokens: 2.5,
+          cacheReadPer1mTokens: 0.2,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 4,
+              outputPer1mTokens: 15,
+              cacheWritePer1mTokens: 5,
+              cacheReadPer1mTokens: 0.4,
+            },
+          ],
+        },
+      },
+      {
+        id: "openai/gpt-6-luna",
+        displayName: "GPT-6 Luna",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 0.1,
+          outputPer1mTokens: 0.5,
+          cacheWritePer1mTokens: 0.125,
+          cacheReadPer1mTokens: 0.01,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 0.2,
+              outputPer1mTokens: 0.75,
+              cacheWritePer1mTokens: 0.25,
+              cacheReadPer1mTokens: 0.02,
+            },
+          ],
+        },
+      },
+      {
+        id: "openai/gpt-6-luna-pro",
+        displayName: "GPT-6 Luna Pro",
+        contextWindowTokens: 1050000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens:
+          OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+        supportsThinking: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        supportsPromptCacheBreakpoints: true,
+        maxEffort: "max",
+        supportedEfforts: ["low", "medium", "high", "xhigh", "max"],
+        pricing: {
+          inputPer1mTokens: 0.1,
+          outputPer1mTokens: 0.5,
+          cacheWritePer1mTokens: 0.125,
+          cacheReadPer1mTokens: 0.01,
+          tiers: [
+            {
+              inputTokenThreshold: OPENAI_LONG_CONTEXT_PRICING_THRESHOLD_TOKENS,
+              inputPer1mTokens: 0.2,
+              outputPer1mTokens: 0.75,
+              cacheWritePer1mTokens: 0.25,
+              cacheReadPer1mTokens: 0.02,
+            },
+          ],
+        },
+      },
       // GPT-5.6 family (Sol / Terra / Luna). The `*-pro` slugs are the same
       // underlying models served with `reasoning.mode: pro` at identical
       // rates. cacheWrite is the 1.25x-input rate GPT-5.6+ bills for prompt
@@ -2142,6 +2358,24 @@ const RAW_PROVIDER_CATALOG: ProviderCatalogEntry[] = [
           cacheReadPer1mTokens: 1,
         },
       },
+      {
+        id: "anthropic/claude-opus-5.5",
+        displayName: "Claude Opus 5.5",
+        contextWindowTokens: 1000000,
+        maxOutputTokens: 128000,
+        longContextPricingThresholdTokens: 200000,
+        supportsThinking: true,
+        adaptiveThinkingOnly: true,
+        supportsCaching: true,
+        supportsVision: true,
+        supportsToolUse: true,
+        pricing: {
+          inputPer1mTokens: 4,
+          outputPer1mTokens: 20,
+          cacheWritePer1mTokens: 5,
+          cacheReadPer1mTokens: 0.2,
+        },
+      },
       {
         id: "anthropic/claude-opus-5",
         displayName: "Claude Opus 5",

package/src/providers/openai/codex-models.ts

@@ -10,6 +10,8 @@
  */
 export const CODEX_SUBSCRIPTION_MODEL_IDS: ReadonlySet<string> = new Set([
   "gpt-6-astra",
+  "gpt-6-sol",
+  "gpt-6-luna",
   "gpt-5.6-sol",
   "gpt-5.6-terra",
   "gpt-5.6-luna",

package/src/skills/validate-input.ts

@@ -3,10 +3,11 @@
  *
  * Deliberate strict subset of JSON Schema: it covers only the keywords
  * actually used by `assistant/src/config/bundled-skills/**\/TOOLS.json`
- * (required / type / enum / items.type) plus unknown-key detection. Anything
- * else (`$ref`, `oneOf`, `anyOf`, `allOf`, `format`, `pattern`, `minimum`,
- * `maximum`, object-shape `additionalProperties`, etc.) is silently skipped so
- * a richer schema can never cause us to reject a legitimate call.
+ * (required / type / enum / nested properties and items / required-only oneOf)
+ * plus unknown-key detection. Anything else (`$ref`, richer `oneOf`, `anyOf`,
+ * `allOf`, `format`, `pattern`, `minimum`, `maximum`, object-shape
+ * `additionalProperties`, etc.) is skipped. Nested objects allow extra keys
+ * unless their schema explicitly closes them.
  *
  * Each error message is written to be agent-readable and self-correcting
  * (e.g. `surface_id is required`, `mode must be one of "replace", "append"`).
@@ -313,6 +314,15 @@ export function validateInputAgainstSchema(
   _toolName: string,
   input: Record<string, unknown>,
   schema: Record<string, unknown> | undefined,
+): InputValidationResult {
+  return validateObjectInput(input, schema, "", true);
+}
+
+function validateObjectInput(
+  input: Record<string, unknown>,
+  schema: Record<string, unknown> | undefined,
+  path: string,
+  rejectUnknown: boolean,
 ): InputValidationResult {
   // Skip when there's no schema or no properties block — matches today's
   // lenient behaviour for tools that declare only `{ type: "object" }`.
@@ -338,17 +348,46 @@ export function validateInputAgainstSchema(
         continue;
       }
       if (!(key in input)) {
-        errors.push(`${key} is required`);
+        errors.push(`${path}${key} is required`);
       }
     }
   }
 
+  // Only enforce alternatives whose complete contract is field presence.
+  // Richer unions stay permissive because unsupported keywords can decide
+  // which branch matches.
+  const alternatives = schema.oneOf;
+  if (
+    Array.isArray(alternatives) &&
+    alternatives.length > 0 &&
+    alternatives.every(
+      (branch) =>
+        isPlainObject(branch) &&
+        Object.keys(branch).every(
+          (key) => key === "required" || key === "description",
+        ) &&
+        Array.isArray(branch.required) &&
+        branch.required.every((key: unknown) => typeof key === "string"),
+    )
+  ) {
+    const choices = alternatives as { required: string[] }[];
+    if (
+      choices.filter((branch) => branch.required.every((key) => key in input))
+        .length !== 1
+    ) {
+      errors.push(
+        `${path ? path.slice(0, -1) : "input"} must match exactly one required field set: ${choices.map((branch) => quoteList(branch.required)).join(" or ")}`,
+      );
+    }
+  }
+
   // 2. Per-property checks: type, enum, items.type.
-  for (const [key, rawSubSchema] of Object.entries(properties)) {
-    if (!(key in input)) {
+  for (const [property, rawSubSchema] of Object.entries(properties)) {
+    if (!(property in input)) {
       continue;
     }
-    const value = input[key];
+    const key = `${path}${property}`;
+    const value = input[property];
     // Skip type-checking for absent values; presence is enforced by the
     // `required` check above. Note: `null` IS a present value and is
     // type-checked below — only schemas that explicitly opt in to null via
@@ -381,13 +420,25 @@ export function validateInputAgainstSchema(
       if (!matchesType(value, type)) {
         errors.push(
           type === "boolean" && typeof value === "string"
-            ? `${key} must be a boolean — pass true or false as a JSON boolean, not a string`
+            ? `${key} must be a boolean: pass true or false as a JSON boolean, not a string`
             : `${key} must be ${typeArticle(type)} ${type}`,
         );
         // No point checking enum/items if the base type is wrong.
         continue;
       }
 
+      if (type === "object" && isPlainObject(value)) {
+        const nested = validateObjectInput(
+          value,
+          rawSubSchema,
+          `${key}.`,
+          rawSubSchema.additionalProperties === false,
+        );
+        if (!nested.ok) {
+          errors.push(...nested.errors);
+        }
+      }
+
       // 2a. Enum (string enums are the only shape used today).
       const enumValues = rawSubSchema.enum;
       if (Array.isArray(enumValues) && enumValues.length > 0) {
@@ -412,6 +463,17 @@ export function validateInputAgainstSchema(
               errors.push(
                 `${key}[${index}] must be ${typeArticle(itemTypeName)} ${itemTypeName}`,
               );
+            } else if (itemTypeName === "object" && isPlainObject(element)) {
+              const itemSchema = rawSubSchema.items as Record<string, unknown>;
+              const nested = validateObjectInput(
+                element,
+                itemSchema,
+                `${key}[${index}].`,
+                itemSchema.additionalProperties === false,
+              );
+              if (!nested.ok) {
+                errors.push(...nested.errors);
+              }
             }
           });
         }
@@ -420,10 +482,12 @@ export function validateInputAgainstSchema(
   }
 
   // 3. Unknown keys — parity with the previous `validateNoUnknownParams`.
-  const unknownKeys = Object.keys(input).filter((k) => !knownKeySet.has(k));
+  const unknownKeys = rejectUnknown
+    ? Object.keys(input).filter((k) => !knownKeySet.has(k))
+    : [];
   for (const key of unknownKeys) {
     errors.push(
-      `Unknown parameter "${key}". Supported: ${quoteList(knownKeys)}`,
+      `Unknown parameter "${path}${key}". Supported: ${quoteList(knownKeys)}`,
     );
   }
 

package/src/tools/skills/execute.ts

@@ -178,7 +178,7 @@ export function augmentSkillExecuteError(
 export const skillExecuteTool = {
   name: "skill_execute",
   description:
-    "Execute a tool provided by a loaded skill. Use this instead of calling skill tools directly. The skill's instructions (from skill_load) describe available tools and their parameters. For browser automation, use the `assistant browser` CLI commands instead.",
+    "Execute a tool provided by a loaded skill. When skill_load is available, call it for the owning skill before first use, even if a capability card says it is available. Use the current instructions and input schema over remembered arguments. Use this instead of calling skill tools directly. For browser automation, use the `assistant browser` CLI commands instead.",
   category: "skills",
   executionTarget: "sandbox",
   defaultRiskLevel: RiskLevel.Low,

package/src/tools/skills/format-input-schema.ts

@@ -0,0 +1,15 @@
+import { getWorkspaceDirDisplay } from "../../util/platform.js";
+
+/** Preserve nested fields and alternatives when disclosing a skill's input. */
+export function formatSkillInputSchema(schema: object): string {
+  const workspaceDir = getWorkspaceDirDisplay();
+  const json = JSON.stringify(
+    schema,
+    (_key, value: unknown) =>
+      typeof value === "string"
+        ? value.replaceAll("{workspaceDir}", workspaceDir)
+        : value,
+    2,
+  );
+  return `Input schema for \`skill_execute.input\`:\n\`\`\`json\n${json}\n\`\`\``;
+}

package/src/tools/skills/load.ts

@@ -35,6 +35,7 @@ import type {
   ToolDefinition,
   ToolExecutionResult,
 } from "../types.js";
+import { formatSkillInputSchema } from "./format-input-schema.js";
 
 /** Skill sources eligible for inline command expansion in v1. */
 const INLINE_COMMAND_ELIGIBLE_SOURCES = new Set([
@@ -123,32 +124,7 @@ function formatToolSchemas(
       tool.description.replaceAll("{workspaceDir}", getWorkspaceDirDisplay()),
     );
 
-    const schema = tool.input_schema;
-    const properties = schema.properties as
-      | Record<string, Record<string, unknown>>
-      | undefined;
-    if (properties && Object.keys(properties).length > 0) {
-      const requiredSet = new Set<string>(
-        Array.isArray(schema.required) ? (schema.required as string[]) : [],
-      );
-
-      lines.push("Parameters:");
-      for (const [paramName, paramDef] of Object.entries(properties)) {
-        const paramType =
-          typeof paramDef.type === "string" ? paramDef.type : "any";
-        const requiredLabel = requiredSet.has(paramName)
-          ? "required"
-          : "optional";
-        const descPart =
-          typeof paramDef.description === "string"
-            ? `: ${paramDef.description.replaceAll("{workspaceDir}", getWorkspaceDirDisplay())}`
-            : "";
-        lines.push(
-          `- ${paramName} (${paramType}, ${requiredLabel})${descPart}`,
-        );
-      }
-    }
-
+    lines.push(formatSkillInputSchema(tool.input_schema));
     lines.push("");
   }
 

package/src/tools/skills/skill-tool-factory.ts

@@ -15,6 +15,7 @@ import { bundledToolInputMisuseMessage } from "../shared/input-misuse.js";
 import { bundledToolInputRepairs } from "../shared/input-repairs.js";
 import type { ExecutionTarget } from "../tool-types.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
+import { formatSkillInputSchema } from "./format-input-schema.js";
 import { runSkillToolScript } from "./skill-script-runner.js";
 
 const riskMap: Record<SkillToolEntry["risk"], RiskLevel> = {
@@ -94,7 +95,7 @@ export function createSkillTool(
         return {
           content:
             misuse ??
-            `Invalid input for tool "${entry.name}": ${validation.errors.join("; ")}. Fix the arguments and retry.`,
+            `Invalid input for tool "${entry.name}": ${validation.errors.join("; ")}. If skill_load is available, load the owning skill for its current instructions. Retry with arguments matching this schema.\n\n${formatSkillInputSchema(entry.input_schema)}`,
           isError: true,
         };
       }