@miaws/miaw 1.18.5 → 1.18.6

package/test/session/structured-output.test.ts

@@ -1,387 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { SessionV1 } from "@miaw/core/v1/session"
-import { Exit, Schema } from "effect"
-import { MessageV2 } from "../../src/session/message-v2"
-import { SessionPrompt } from "../../src/session/prompt"
-import { SessionID, MessageID } from "../../src/session/schema"
-
-const decodeFormat = Schema.decodeUnknownExit(SessionV1.Format)
-const decodeUser = Schema.decodeUnknownExit(SessionV1.User)
-const decodeAssistant = Schema.decodeUnknownExit(SessionV1.Assistant)
-
-describe("structured-output.OutputFormat", () => {
-  test("parses text format", () => {
-    const result = decodeFormat({ type: "text" })
-    expect(Exit.isSuccess(result)).toBe(true)
-    if (Exit.isSuccess(result)) {
-      expect(result.value.type).toBe("text")
-    }
-  })
-
-  test("parses json_schema format with defaults", () => {
-    const result = decodeFormat({
-      type: "json_schema",
-      schema: { type: "object", properties: { name: { type: "string" } } },
-    })
-    expect(Exit.isSuccess(result)).toBe(true)
-    if (Exit.isSuccess(result)) {
-      expect(result.value.type).toBe("json_schema")
-      if (result.value.type === "json_schema") {
-        expect(result.value.retryCount).toBe(2) // default value
-      }
-    }
-  })
-
-  test("parses json_schema format with custom retryCount", () => {
-    const result = decodeFormat({
-      type: "json_schema",
-      schema: { type: "object" },
-      retryCount: 5,
-    })
-    expect(Exit.isSuccess(result)).toBe(true)
-    if (Exit.isSuccess(result) && result.value.type === "json_schema") {
-      expect(result.value.retryCount).toBe(5)
-    }
-  })
-
-  test("rejects invalid type", () => {
-    const result = decodeFormat({ type: "invalid" })
-    expect(Exit.isFailure(result)).toBe(true)
-  })
-
-  test("rejects json_schema without schema", () => {
-    const result = decodeFormat({ type: "json_schema" })
-    expect(Exit.isFailure(result)).toBe(true)
-  })
-
-  test("rejects negative retryCount", () => {
-    const result = decodeFormat({
-      type: "json_schema",
-      schema: { type: "object" },
-      retryCount: -1,
-    })
-    expect(Exit.isFailure(result)).toBe(true)
-  })
-})
-
-describe("structured-output.StructuredOutputError", () => {
-  test("creates error with message and retries", () => {
-    const error = new SessionV1.StructuredOutputError({
-      message: "Failed to validate",
-      retries: 3,
-    })
-
-    expect(error.name).toBe("StructuredOutputError")
-    expect(error.data.message).toBe("Failed to validate")
-    expect(error.data.retries).toBe(3)
-  })
-
-  test("converts to object correctly", () => {
-    const error = new SessionV1.StructuredOutputError({
-      message: "Test error",
-      retries: 2,
-    })
-
-    const obj = error.toObject()
-    expect(obj.name).toBe("StructuredOutputError")
-    expect(obj.data.message).toBe("Test error")
-    expect(obj.data.retries).toBe(2)
-  })
-
-  test("isInstance correctly identifies error", () => {
-    const error = new SessionV1.StructuredOutputError({
-      message: "Test",
-      retries: 1,
-    })
-
-    expect(SessionV1.StructuredOutputError.isInstance(error)).toBe(true)
-    expect(SessionV1.StructuredOutputError.isInstance({ name: "other" })).toBe(false)
-  })
-})
-
-describe("structured-output.UserMessage", () => {
-  test("user message accepts outputFormat", () => {
-    const result = decodeUser({
-      id: MessageID.ascending(),
-      sessionID: SessionID.descending(),
-      role: "user",
-      time: { created: Date.now() },
-      agent: "default",
-      model: { providerID: "anthropic", modelID: "claude-3" },
-      outputFormat: {
-        type: "json_schema",
-        schema: { type: "object" },
-      },
-    })
-    expect(Exit.isSuccess(result)).toBe(true)
-  })
-
-  test("user message works without outputFormat (optional)", () => {
-    const result = decodeUser({
-      id: MessageID.ascending(),
-      sessionID: SessionID.descending(),
-      role: "user",
-      time: { created: Date.now() },
-      agent: "default",
-      model: { providerID: "anthropic", modelID: "claude-3" },
-    })
-    expect(Exit.isSuccess(result)).toBe(true)
-  })
-})
-
-describe("structured-output.AssistantMessage", () => {
-  const baseAssistantMessage = {
-    id: MessageID.ascending(),
-    sessionID: SessionID.descending(),
-    role: "assistant" as const,
-    parentID: MessageID.ascending(),
-    modelID: "claude-3",
-    providerID: "anthropic",
-    mode: "default",
-    agent: "default",
-    path: { cwd: "/test", root: "/test" },
-    cost: 0.001,
-    tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-    time: { created: Date.now() },
-  }
-
-  test("assistant message accepts structured", () => {
-    const result = decodeAssistant({
-      ...baseAssistantMessage,
-      structured: { company: "Anthropic", founded: 2021 },
-    })
-    expect(Exit.isSuccess(result)).toBe(true)
-    if (Exit.isSuccess(result)) {
-      expect(result.value.structured).toEqual({ company: "Anthropic", founded: 2021 })
-    }
-  })
-
-  test("assistant message works without structured_output (optional)", () => {
-    const result = decodeAssistant(baseAssistantMessage)
-    expect(Exit.isSuccess(result)).toBe(true)
-  })
-})
-
-describe("structured-output.createStructuredOutputTool", () => {
-  test("creates tool with description", () => {
-    const tool = SessionPrompt.createStructuredOutputTool({
-      schema: { type: "object" },
-      onSuccess: () => {},
-    })
-
-    expect(tool.description).toContain("structured format")
-  })
-
-  test("creates tool with schema as inputSchema", () => {
-    const schema = {
-      type: "object",
-      properties: {
-        company: { type: "string" },
-        founded: { type: "number" },
-      },
-      required: ["company"],
-    }
-
-    const tool = SessionPrompt.createStructuredOutputTool({
-      schema,
-      onSuccess: () => {},
-    })
-
-    // AI SDK wraps schema in { jsonSchema: {...} }
-    expect(tool.inputSchema).toBeDefined()
-    const inputSchema = tool.inputSchema as any
-    expect(inputSchema.jsonSchema?.properties?.company).toBeDefined()
-    expect(inputSchema.jsonSchema?.properties?.founded).toBeDefined()
-  })
-
-  test("strips $schema property from inputSchema", () => {
-    const schema = {
-      $schema: "http://json-schema.org/draft-07/schema#",
-      type: "object",
-      properties: { name: { type: "string" } },
-    }
-
-    const tool = SessionPrompt.createStructuredOutputTool({
-      schema,
-      onSuccess: () => {},
-    })
-
-    // AI SDK wraps schema in { jsonSchema: {...} }
-    const inputSchema = tool.inputSchema as any
-    expect(inputSchema.jsonSchema?.$schema).toBeUndefined()
-  })
-
-  test("execute calls onSuccess with valid args", async () => {
-    let capturedOutput: unknown
-
-    const tool = SessionPrompt.createStructuredOutputTool({
-      schema: { type: "object", properties: { name: { type: "string" } } },
-      onSuccess: (output) => {
-        capturedOutput = output
-      },
-    })
-
-    expect(tool.execute).toBeDefined()
-    const testArgs = { name: "Test Company" }
-    const result = await tool.execute!(testArgs, {
-      toolCallId: "test-call-id",
-      messages: [],
-      abortSignal: undefined as any,
-    })
-
-    expect(capturedOutput).toEqual(testArgs)
-    expect(result.output).toBe("Structured output captured successfully.")
-    expect(result.metadata.valid).toBe(true)
-  })
-
-  test("AI SDK validates schema before execute - missing required field", async () => {
-    // Note: The AI SDK validates the input against the schema BEFORE calling execute()
-    // So invalid inputs never reach the tool's execute function
-    // This test documents the expected schema behavior
-    const tool = SessionPrompt.createStructuredOutputTool({
-      schema: {
-        type: "object",
-        properties: {
-          name: { type: "string" },
-          age: { type: "number" },
-        },
-        required: ["name", "age"],
-      },
-      onSuccess: () => {},
-    })
-
-    // The schema requires both 'name' and 'age'
-    expect(tool.inputSchema).toBeDefined()
-    const inputSchema = tool.inputSchema as any
-    expect(inputSchema.jsonSchema?.required).toContain("name")
-    expect(inputSchema.jsonSchema?.required).toContain("age")
-  })
-
-  test("AI SDK validates schema types before execute - wrong type", async () => {
-    // Note: The AI SDK validates the input against the schema BEFORE calling execute()
-    // So invalid inputs never reach the tool's execute function
-    // This test documents the expected schema behavior
-    const tool = SessionPrompt.createStructuredOutputTool({
-      schema: {
-        type: "object",
-        properties: {
-          count: { type: "number" },
-        },
-        required: ["count"],
-      },
-      onSuccess: () => {},
-    })
-
-    // The schema defines 'count' as a number
-    expect(tool.inputSchema).toBeDefined()
-    const inputSchema = tool.inputSchema as any
-    expect(inputSchema.jsonSchema?.properties?.count?.type).toBe("number")
-  })
-
-  test("execute handles nested objects", async () => {
-    let capturedOutput: unknown
-
-    const tool = SessionPrompt.createStructuredOutputTool({
-      schema: {
-        type: "object",
-        properties: {
-          user: {
-            type: "object",
-            properties: {
-              name: { type: "string" },
-              email: { type: "string" },
-            },
-            required: ["name"],
-          },
-        },
-        required: ["user"],
-      },
-      onSuccess: (output) => {
-        capturedOutput = output
-      },
-    })
-
-    // Valid nested object - AI SDK validates before calling execute()
-    const validResult = await tool.execute!(
-      { user: { name: "John", email: "john@test.com" } },
-      {
-        toolCallId: "test-call-id",
-        messages: [],
-        abortSignal: undefined as any,
-      },
-    )
-
-    expect(capturedOutput).toEqual({ user: { name: "John", email: "john@test.com" } })
-    expect(validResult.metadata.valid).toBe(true)
-
-    // Verify schema has correct nested structure
-    const inputSchema = tool.inputSchema as any
-    expect(inputSchema.jsonSchema?.properties?.user?.type).toBe("object")
-    expect(inputSchema.jsonSchema?.properties?.user?.properties?.name?.type).toBe("string")
-    expect(inputSchema.jsonSchema?.properties?.user?.required).toContain("name")
-  })
-
-  test("execute handles arrays", async () => {
-    let capturedOutput: unknown
-
-    const tool = SessionPrompt.createStructuredOutputTool({
-      schema: {
-        type: "object",
-        properties: {
-          tags: {
-            type: "array",
-            items: { type: "string" },
-          },
-        },
-        required: ["tags"],
-      },
-      onSuccess: (output) => {
-        capturedOutput = output
-      },
-    })
-
-    // Valid array - AI SDK validates before calling execute()
-    const validResult = await tool.execute!(
-      { tags: ["a", "b", "c"] },
-      {
-        toolCallId: "test-call-id",
-        messages: [],
-        abortSignal: undefined as any,
-      },
-    )
-
-    expect(capturedOutput).toEqual({ tags: ["a", "b", "c"] })
-    expect(validResult.metadata.valid).toBe(true)
-
-    // Verify schema has correct array structure
-    const inputSchema = tool.inputSchema as any
-    expect(inputSchema.jsonSchema?.properties?.tags?.type).toBe("array")
-    expect(inputSchema.jsonSchema?.properties?.tags?.items?.type).toBe("string")
-  })
-
-  test("toModelOutput returns text value", async () => {
-    const tool = SessionPrompt.createStructuredOutputTool({
-      schema: { type: "object" },
-      onSuccess: () => {},
-    })
-
-    expect(tool.toModelOutput).toBeDefined()
-    const modelOutput = await Promise.resolve(
-      tool.toModelOutput!({
-        toolCallId: "test-call-id",
-        input: {},
-        output: {
-          output: "Test output",
-        },
-      }),
-    )
-
-    expect(modelOutput.type).toBe("text")
-    if (modelOutput.type !== "text") throw new Error("expected text model output")
-    expect(modelOutput.value).toBe("Test output")
-  })
-
-  // Note: Retry behavior is handled by the AI SDK and the prompt loop, not the tool itself
-  // The tool simply calls onSuccess when execute() is called with valid args
-  // See prompt.ts loop() for actual retry logic
-})

package/test/session/system.test.ts

@@ -1,86 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import type { Agent } from "../../src/agent/agent"
-import { NamedError } from "@miaw/core/util/error"
-import { Skill } from "../../src/skill"
-import { Permission } from "../../src/permission"
-import { SystemPrompt } from "../../src/session/system"
-import { LocationServiceMap } from "@miaw/core/location-layer"
-import { testEffect } from "../lib/effect"
-
-const skills: Skill.Info[] = [
-  {
-    name: "zeta-skill",
-    description: "Zeta skill.",
-    location: "/tmp/zeta-skill/SKILL.md",
-    content: "# zeta-skill",
-  },
-  {
-    name: "alpha-skill",
-    description: "Alpha skill.",
-    location: "/tmp/alpha-skill/SKILL.md",
-    content: "# alpha-skill",
-  },
-  {
-    name: "middle-skill",
-    description: "Middle skill.",
-    location: "/tmp/middle-skill/SKILL.md",
-    content: "# middle-skill",
-  },
-  {
-    name: "manual-skill",
-    location: "/tmp/manual-skill/SKILL.md",
-    content: "# manual-skill",
-  },
-]
-
-const build: Agent.Info = {
-  name: "build",
-  mode: "primary",
-  permission: Permission.fromConfig({ "*": "allow" }),
-  options: {},
-}
-
-const it = testEffect(
-  SystemPrompt.layer.pipe(
-    Layer.provide(LocationServiceMap.layer),
-    Layer.provide(
-      Layer.succeed(
-        Skill.Service,
-        Skill.Service.of({
-          get: (name) => Effect.succeed(skills.find((skill) => skill.name === name)),
-          require: (name) => {
-            const info = skills.find((skill) => skill.name === name)
-            if (info) return Effect.succeed(info)
-            return Effect.fail(new Skill.NotFoundError({ name, available: skills.map((skill) => skill.name) }))
-          },
-          all: () => Effect.succeed(skills),
-          dirs: () => Effect.succeed([]),
-          available: () => Effect.succeed(skills),
-        }),
-      ),
-    ),
-  ),
-)
-
-describe("session.system", () => {
-  it.effect("skills output is sorted by name and stable across calls", () =>
-    Effect.gen(function* () {
-      const prompt = yield* SystemPrompt.Service
-      const first = yield* prompt.skills(build)
-      const second = yield* prompt.skills(build)
-      const output = first ?? (yield* Effect.fail(new NamedError.Unknown({ message: "missing skills output" })))
-
-      expect(first).toBe(second)
-
-      const alpha = output.indexOf("<name>alpha-skill</name>")
-      const middle = output.indexOf("<name>middle-skill</name>")
-      const zeta = output.indexOf("<name>zeta-skill</name>")
-
-      expect(alpha).toBeGreaterThan(-1)
-      expect(middle).toBeGreaterThan(alpha)
-      expect(zeta).toBeGreaterThan(middle)
-      expect(output).not.toContain("manual-skill")
-    }),
-  )
-})

package/test/session/ultrawork.test.ts

@@ -1,25 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { SessionUltrawork } from "../../src/session/ultrawork"
-
-describe("session.ultrawork", () => {
-  test("injects ultrawork instructions when text starts with ulw", () => {
-    const input = SessionUltrawork.applyTrigger({
-      system: "existing system",
-      parts: [{ type: "text" as const, text: "ulw buatkan fitur" }],
-    })
-
-    expect(input.parts[0]).toEqual({ type: "text", text: "ulw buatkan fitur" })
-    expect(input.system).toContain("existing system")
-    expect(input.system).toContain("[search-mode]")
-    expect(input.system).toContain("<ultrawork-mode>")
-    expect(input.system).toContain("ULTRAWORK MODE ENABLED!")
-  })
-
-  test("ignores ulw when it is not the first text token", () => {
-    const input = SessionUltrawork.applyTrigger({
-      parts: [{ type: "text" as const, text: "please ulw buatkan fitur" }],
-    })
-
-    expect(input.system).toBeUndefined()
-  })
-})