ctx API

const completion = await ctx.model.complete({
  tier: "cheap",
  messages: [
    { role: "system", content: "You classify emails." },
    { role: "user", content: subject },
  ],
});
if (!completion.ok) return completion;
// completion.value: { text, inputTokens, outputTokens, modelId }

type Result<T> =
  | { ok: true; value: T }
  | {
      ok: false;
      error: {
        code: string;
        message: string;
        retryable?: boolean;
        [k: string]: unknown;
      };
    };

// src/tools/draftReply.ts
import type { ToolHandler } from "@tiffy/app-sdk";

export const draftReply: ToolHandler = async (ctx, input) => {
  const { messageId } = input as { messageId: string };

  const found = await ctx.notes.search(messageId, { limit: 1 });
  if (!found.ok) return found;

  const completion = await ctx.model.complete({
    messages: [
      { role: "system", content: "You draft concise email replies." },
      { role: "user", content: `Draft a reply to: ${messageId}` },
    ],
  });
  if (!completion.ok) return completion;

  return { ok: true, value: { draft: completion.value.text } };
};

// src/index.ts
import { defineApp } from "@tiffy/app-sdk";
import { draftReply } from "./tools/draftReply";
import { mailArrived } from "./triggers/mailArrived";

export default defineApp({
  tools: { "mail.draftReply": draftReply },
  triggers: { "mail.arrived": mailArrived },
});

// src/triggers/mailArrived.ts
import type { TriggerHandler } from "@tiffy/app-sdk";

export const mailArrived: TriggerHandler = async (ctx) => {
  const cursor = await ctx.kv.get<string>("last-uid");
  const lastUid = cursor.ok ? (cursor.value ?? "0") : "0";

  const res = await ctx.fetch(`https://imap.example.com/messages?since=${lastUid}`);
  if (!res.ok) {
    ctx.log.warn("mail.arrived poll failed", { code: res.error.code });
    return;
  }

  const messages = JSON.parse(res.body) as { id: string }[];
  for (const message of messages) {
    await ctx.events.emit({ kind: "mail.arrived", dedupeKey: message.id, payload: message });
  }
  if (messages.length > 0) {
    await ctx.kv.set("last-uid", messages[messages.length - 1].id);
  }
};

// test/mailArrived.test.ts
import { describe, expect, it } from "vitest";
import { createMockContext } from "@tiffy/app-sdk/testing";
import { mailArrived } from "../src/triggers/mailArrived";

describe("mail.arrived", () => {
  it("fetches the declared host and moves the kv cursor forward", async () => {
    const { ctx, kvStore, fetchCalls, eventsEmitted } = createMockContext({
      scopes: ["network:imap.example.com"],
      fetchResponses: {
        "https://imap.example.com/messages?since=0": {
          status: 200,
          headers: {},
          body: JSON.stringify([{ id: "42" }]),
        },
      },
    });

    await mailArrived(ctx);

    expect(fetchCalls).toEqual([{ url: "https://imap.example.com/messages?since=0" }]);
    expect(kvStore.get("last-uid")).toBe("42");
    expect(eventsEmitted).toEqual([{ kind: "mail.arrived", dedupeKey: "42", payload: { id: "42" } }]);
  });

  it("모의 응답이 없으면 경고 로그를 남기고 커서를 건드리지 않는다", async () => {
    // scopes와 fetchResponses를 모두 생략했으므로 ctx.fetch는 no_mock_response로 실패한다
    const { ctx, kvStore, log } = createMockContext({});

    await mailArrived(ctx);

    expect(kvStore.has("last-uid")).toBe(false);
    expect(log.some((l) => l.level === "warn")).toBe(true);
  });
});

// test/draftReply.test.ts
import { describe, expect, it } from "vitest";
import { createMockContext } from "@tiffy/app-sdk/testing";
import { draftReply } from "../src/tools/draftReply";

describe("mail.draftReply", () => {
  it("returns a draft from the model reply", async () => {
    const { ctx } = createMockContext({
      modelReplies: ["Thanks, I'll get back to you tomorrow."],
    });

    const result = await draftReply(ctx, { messageId: "msg_1" });

    expect(result.ok).toBe(true);
  });

  it("rejects a fetch to a host that isn't declared in scopes", async () => {
    const { ctx } = createMockContext({ scopes: ["network:imap.example.com"] });

    const res = await ctx.fetch("https://evil.example.com/steal");

    expect(res.ok).toBe(false);
    if (!res.ok) expect(res.error.code).toBe("scope_denied");
  });
});