@vellumai/assistant 0.5.0 → 0.5.2

package/src/__tests__/schema-transforms.test.ts

@@ -70,21 +70,53 @@ describe("injectActivityField", () => {
     expect("activity" in props0).toBe(false);
   });
 
-  test("skips tools that already have activity in properties", () => {
+  test("returns unchanged when activity is in top-level properties but not required", () => {
     const defs = [
       makeDef("my_tool", {
         type: "object",
         properties: { activity: { type: "number" } },
-        required: [],
+        required: ["foo"],
       }),
     ];
     const result = injectActivityField(defs);
-    // Should be the exact same object reference (no clone needed)
+    // Should be the exact same object reference (no modification)
     expect(Object.is(result[0], defs[0])).toBe(true);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
     // Original activity type preserved
     expect(props.activity).toEqual({ type: "number" });
+    // required NOT modified — don't promote server-defined optional activity
+    expect(schema.required).toEqual(["foo"]);
+  });
+
+  test("returns unchanged when activity is in both top-level properties AND required", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { activity: { type: "string" } },
+        required: ["activity"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    const schema = result[0].input_schema as Record<string, unknown>;
+    const props = schema.properties as Record<string, unknown>;
+    // Original activity type preserved
+    expect(props.activity).toEqual({ type: "string" });
+    // activity must be in required even though it was already in properties
+    expect(schema.required).toEqual(["activity"]);
+  });
+
+  test("skips tools that already have activity in both properties and required", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { activity: { type: "number" } },
+        required: ["activity"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    // Should be the exact same object reference (no clone needed)
+    expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
   test("does NOT mutate original definition objects", () => {
@@ -125,6 +157,60 @@ describe("injectActivityField", () => {
     expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
+  test("does NOT add activity to top-level required when only in oneOf branch", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { shared: { type: "string" } },
+        oneOf: [
+          {
+            properties: {
+              activity: { type: "string" },
+              branch_a: { type: "number" },
+            },
+          },
+          {
+            properties: { branch_b: { type: "boolean" } },
+          },
+        ],
+        required: ["shared"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    // Should be the exact same object reference (no modification)
+    expect(Object.is(result[0], defs[0])).toBe(true);
+    const schema = result[0].input_schema as Record<string, unknown>;
+    // Top-level required should NOT include activity
+    expect(schema.required).toEqual(["shared"]);
+    // Top-level properties should NOT have activity injected
+    const props = schema.properties as Record<string, unknown>;
+    expect("activity" in props).toBe(false);
+  });
+
+  test("does NOT add activity to top-level required when only in allOf sub-schema with additionalProperties: false", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { foo: { type: "string" } },
+        additionalProperties: false,
+        allOf: [
+          {
+            properties: { activity: { type: "string" } },
+          },
+        ],
+        required: ["foo"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    // Should be the exact same object reference (no modification)
+    expect(Object.is(result[0], defs[0])).toBe(true);
+    const schema = result[0].input_schema as Record<string, unknown>;
+    // Top-level required should NOT include activity
+    expect(schema.required).toEqual(["foo"]);
+    const props = schema.properties as Record<string, unknown>;
+    expect("activity" in props).toBe(false);
+  });
+
   test("skips tools with activity defined inside allOf member (composite schema)", () => {
     const defs = [
       makeDef("my_tool", {
@@ -139,18 +225,92 @@ describe("injectActivityField", () => {
       }),
     ];
     const result = injectActivityField(defs);
-    // Should be the exact same object reference (no injection)
+    // Should be the exact same object reference (no modification)
     expect(Object.is(result[0], defs[0])).toBe(true);
     const schema = result[0].input_schema as Record<string, unknown>;
     const props = schema.properties as Record<string, unknown>;
-    // Top-level properties should NOT have activity injected
+    // Top-level properties should NOT have activity injected (it's in allOf)
     expect("activity" in props).toBe(false);
+    // Top-level required should NOT include activity (it's only in composite sub-schemas)
+    expect(schema.required).toEqual([]);
+  });
+
+  test("skips allOf composite schema where activity is already required", () => {
+    const defs = [
+      makeDef("my_tool", {
+        type: "object",
+        properties: { foo: { type: "string" } },
+        allOf: [
+          {
+            properties: { activity: { type: "string" } },
+          },
+        ],
+        required: ["activity"],
+      }),
+    ];
+    const result = injectActivityField(defs);
+    // Should be the exact same object reference (no change needed)
+    expect(Object.is(result[0], defs[0])).toBe(true);
   });
 
   test("handles empty definitions array", () => {
     const result = injectActivityField([]);
     expect(result).toEqual([]);
   });
+
+  test("injects activity only on tools that don't define it at all", () => {
+    const defs = [
+      // Normal tool without activity — should get it injected
+      makeDef("tool_a", {
+        type: "object",
+        properties: { foo: { type: "string" } },
+        required: ["foo"],
+      }),
+      // Tool defines activity in properties but NOT in required — left unchanged
+      makeDef("tool_b", {
+        type: "object",
+        properties: {
+          bar: { type: "string" },
+          activity: { type: "string", description: "custom activity" },
+        },
+        required: ["bar"],
+      }),
+      // Tool that defines activity in both properties AND required — left unchanged
+      makeDef("tool_c", {
+        type: "object",
+        properties: {
+          baz: { type: "number" },
+          activity: { type: "string", description: "custom activity" },
+        },
+        required: ["baz", "activity"],
+      }),
+      // Non-object schema — should be left alone
+      makeDef("tool_d", { type: "string" }),
+      // Object schema without properties — should be left alone
+      makeDef("tool_e", { type: "object" }),
+    ];
+
+    const result = injectActivityField(defs);
+
+    // tool_a: activity injected and required
+    const schemaA = result[0].input_schema as Record<string, unknown>;
+    expect(
+      (schemaA.properties as Record<string, unknown>).activity,
+    ).toBeDefined();
+    expect(schemaA.required).toEqual(["foo", "activity"]);
+
+    // tool_b: unchanged (activity optional, not promoted)
+    expect(Object.is(result[1], defs[1])).toBe(true);
+    const schemaB = result[1].input_schema as Record<string, unknown>;
+    expect(schemaB.required).toEqual(["bar"]);
+
+    // tool_c: unchanged (activity already present and required)
+    expect(Object.is(result[2], defs[2])).toBe(true);
+
+    // tool_d, tool_e: unchanged
+    expect(Object.is(result[3], defs[3])).toBe(true);
+    expect(Object.is(result[4], defs[4])).toBe(true);
+  });
 });
 
 describe("schemaDefinesProperty", () => {

package/src/__tests__/server-history-render.test.ts

@@ -330,7 +330,7 @@ describe("getAttachmentsForMessage", () => {
 
   test("returns attachments linked to a message", async () => {
     const msgId = await createMessage("assistant", "Here is a chart");
-    const stored = uploadAttachment("chart.png", "image/png", "iVBOR");
+    const stored = uploadAttachment("chart.png", "image/png", "iVBORw==");
     linkAttachmentToMessage(msgId, stored.id, 0);
 
     const result = getAttachmentsForMessage(msgId);
@@ -338,7 +338,7 @@ describe("getAttachmentsForMessage", () => {
     expect(result[0].id).toBe(stored.id);
     expect(result[0].originalFilename).toBe("chart.png");
     expect(result[0].mimeType).toBe("image/png");
-    expect(result[0].dataBase64).toBe("iVBOR");
+    expect(result[0].dataBase64).toBe("iVBORw==");
   });
 
   test("returns empty array when no attachments are linked", () => {

package/src/__tests__/skill-feature-flags-integration.test.ts

@@ -138,14 +138,15 @@ describe("frontmatter feature-flag integration", () => {
     expect(key).toBeUndefined();
   });
 
-  test("resolveSkillStates gates skill with featureFlag when flag is OFF", () => {
+  test("resolveSkillStates includes skill with featureFlag when flag defaults to ON", () => {
     const skill = buildSkillSummary("contacts", SKILL_MD_WITH_FLAG)!;
-    // "contacts" is in the registry with defaultEnabled: false
+    // "contacts" is in the registry with defaultEnabled: true
     const config = makeConfig();
 
     const resolved = resolveSkillStates([skill], config);
-    // Flag defaults to false → skill is filtered out
-    expect(resolved.length).toBe(0);
+    // Flag defaults to true → skill passes through
+    expect(resolved.length).toBe(1);
+    expect(resolved[0].summary.id).toBe("contacts");
   });
 
   test("resolveSkillStates includes skill with featureFlag when flag is ON", () => {
@@ -192,22 +193,22 @@ describe("frontmatter feature-flag integration", () => {
     const key = skillFlagKey(skill);
     expect(key).toBe("feature_flags.contacts.enabled");
 
-    // Step 4: Check flag state — "contacts" has defaultEnabled: false in registry
-    const configOff = makeConfig();
-    expect(isAssistantFeatureFlagEnabled(key!, configOff)).toBe(false);
+    // Step 4: Check flag state — "contacts" has defaultEnabled: true in registry
+    const configDefault = makeConfig();
+    expect(isAssistantFeatureFlagEnabled(key!, configDefault)).toBe(true);
 
-    // Step 5: resolveSkillStates correctly filters it out
-    const resolvedOff = resolveSkillStates([skill], configOff);
-    expect(resolvedOff.length).toBe(0);
+    // Step 5: resolveSkillStates includes it by default
+    const resolvedDefault = resolveSkillStates([skill], configDefault);
+    expect(resolvedDefault.length).toBe(1);
+    expect(resolvedDefault[0].summary.id).toBe("contacts");
 
-    // Step 6: With override enabled, skill passes through
-    const configOn = makeConfig({
-      assistantFeatureFlagValues: { [key!]: true },
+    // Step 6: With override disabled, skill is filtered out
+    const configOff = makeConfig({
+      assistantFeatureFlagValues: { [key!]: false },
     });
-    expect(isAssistantFeatureFlagEnabled(key!, configOn)).toBe(true);
+    expect(isAssistantFeatureFlagEnabled(key!, configOff)).toBe(false);
 
-    const resolvedOn = resolveSkillStates([skill], configOn);
-    expect(resolvedOn.length).toBe(1);
-    expect(resolvedOn[0].summary.id).toBe("contacts");
+    const resolvedOff = resolveSkillStates([skill], configOff);
+    expect(resolvedOff.length).toBe(0);
   });
 });

package/src/__tests__/skill-feature-flags.test.ts

@@ -81,14 +81,14 @@ describe("skillFlagKey", () => {
 // ---------------------------------------------------------------------------
 
 describe("isAssistantFeatureFlagEnabled with skillFlagKey", () => {
-  test("returns false when no flag overrides (registry default is false)", () => {
+  test("returns true when no flag overrides (registry default is true)", () => {
     const config = makeConfig();
     expect(
       isAssistantFeatureFlagEnabled(
         skillFlagKey({ featureFlag: DECLARED_FLAG_ID })!,
         config,
       ),
-    ).toBe(false);
+    ).toBe(true);
   });
 
   test("returns true when skill key is explicitly true", () => {
@@ -140,10 +140,8 @@ describe("isAssistantFeatureFlagEnabled", () => {
 
   test("falls back to registry default when no override", () => {
     const config = makeConfig();
-    // contacts defaults to false in the registry
-    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(
-      false,
-    );
+    // contacts defaults to true in the registry
+    expect(isAssistantFeatureFlagEnabled(DECLARED_FLAG_KEY, config)).toBe(true);
   });
 
   test("respects persisted overrides for undeclared keys", () => {
@@ -207,13 +205,14 @@ describe("resolveSkillStates with feature flags", () => {
     expect(ids).toContain("browser");
   });
 
-  test("declared flag key defaults to registry value (false)", () => {
+  test("declared flag key defaults to registry value (true)", () => {
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
-    // contacts registry default is false, so it's filtered out
-    expect(resolved.length).toBe(0);
+    // contacts registry default is true, so it passes through
+    expect(resolved.length).toBe(1);
+    expect(resolved[0].summary.id).toBe(DECLARED_SKILL_ID);
   });
 
   test("skill without featureFlag is never flag-gated", () => {
@@ -280,14 +279,15 @@ describe("resolveSkillStates with feature flags", () => {
 // ---------------------------------------------------------------------------
 
 describe("resolveSkillStates with frontmatter featureFlag", () => {
-  test("skill with featureFlag (defaultEnabled: false) is filtered when no config override", () => {
-    // contacts has defaultEnabled: false in the registry
+  test("skill with featureFlag (defaultEnabled: true) is included when no config override", () => {
+    // contacts has defaultEnabled: true in the registry
     const catalog = [makeSkill(DECLARED_SKILL_ID, "bundled", DECLARED_FLAG_ID)];
     const config = makeConfig();
 
     const resolved = resolveSkillStates(catalog, config);
-    // No override, registry default is false → filtered out
-    expect(resolved.length).toBe(0);
+    // No override, registry default is true → passes through
+    expect(resolved.length).toBe(1);
+    expect(resolved[0].summary.id).toBe(DECLARED_SKILL_ID);
   });
 
   test("skill with featureFlag is included when config override enables it", () => {

package/src/__tests__/skill-load-feature-flag.test.ts

@@ -166,7 +166,7 @@ describe("skill_load feature flag enforcement", () => {
     expect(result.content).toContain("Skill: Contacts");
   });
 
-  test("rejects skill when flag key is absent (registry defaults to disabled)", async () => {
+  test("loads skill when flag key is absent (registry defaults to enabled)", async () => {
     writeSkill(
       DECLARED_SKILL_ID,
       "Contacts",
@@ -184,8 +184,8 @@ describe("skill_load feature flag enforcement", () => {
 
     const result = await executeSkillLoad({ skill: DECLARED_SKILL_ID });
 
-    // contacts is declared in the registry with defaultEnabled: false
-    expect(result.isError).toBe(true);
-    expect(result.content).toContain("disabled by feature flag");
+    // contacts is declared in the registry with defaultEnabled: true
+    expect(result.isError).toBe(false);
+    expect(result.content).toContain("Skill: Contacts");
   });
 });

package/src/__tests__/slack-app-setup-skill-regression.test.ts

@@ -9,7 +9,9 @@ const skillContent = readFileSync(SKILL_PATH, "utf-8");
 
 describe("slack-app-setup skill regression", () => {
   test("keeps Slack token collection on the secure credential prompt path", () => {
-    expect(skillContent).toContain('`credential_store` with `action: "prompt"`');
+    expect(skillContent).toContain(
+      '`credential_store` with `action: "prompt"`',
+    );
     expect(skillContent).toContain(
       "same Slack settings handler used by Settings",
     );

package/src/__tests__/slack-inbound-verification.test.ts

@@ -163,11 +163,11 @@ describe("Slack inbound trusted contact verification", () => {
     // Verification code is NOT sent to the requester — only the guardian
     // receives it via the access request notification flow
 
-    // Channel reply tells user the owner has been notified
+    // Channel reply tells user they're not recognized yet
     expect(deliverReplyCalls.length).toBe(1);
     expect(
       (deliverReplyCalls[0].payload as Record<string, unknown>).text,
-    ).toContain("notified the owner");
+    ).toContain("I don't recognize you yet");
   });
 
   test("verification session is identity-bound to the Slack user", async () => {

package/src/__tests__/starter-task-flow.test.ts

@@ -39,6 +39,7 @@ function makeContext(): SurfaceConversationContext {
     >(),
     surfaceState: new Map(),
     surfaceUndoStacks: new Map(),
+    accumulatedSurfaceState: new Map(),
     surfaceActionRequestIds: new Set<string>(),
     currentTurnSurfaces: [],
     isProcessing: () => false,