Build agents

import { defineAgent } from "@meetluno/luno/agent";
import { lookupCustomer } from "../actions/lookup-customer";

export default defineAgent({
  slug: "support",
  name: "Support",
  description: "Helps customers using the lookupCustomer tool.",
  systemPrompt: "Help customers. Use lookupCustomer to find account details.",
  model: "openai/gpt-5.6-sol",
  tools: [lookupCustomer],
});

import { defineAgent } from "@meetluno/luno/agent";
import researcher from "./researcher";

export default defineAgent({
  slug: "orchestrator",
  name: "Orchestrator",
  description: "Delegates research tasks to a researcher subagent.",
  systemPrompt:
    "You are an orchestrator. For research tasks, call researcher before answering.",
  model: "openai/gpt-5.6-terra",
  tools: [researcher],
});

export default defineAgent({
  slug: "orchestrator",
  name: "Orchestrator",
  description: "Coordinates research and writing.",
  systemPrompt: "Delegate research to researcher and writing to writer, then answer.",
  model: "openai/gpt-5.6-terra",
  tools: [researcher, writer],
  subagents: {
    // Recent conversation sent along with every delegation (default: only the task).
    context: { messages: 4 },
    onDelegationStart: ({ agent, prompt, iteration }) => {
      if (agent === "researcher" && iteration > 3) {
        return { proceed: false, rejectionReason: "Research budget used up; answer with what you have." };
      }
      return { prompt: `${prompt}\n\nCite your sources.`, maxSteps: 8 };
    },
    onDelegationComplete: ({ agent, text, success }) =>
      success ? { resultText: text.slice(0, 4000) } : undefined,
  },
});

import { defineAgent } from "@meetluno/luno/agent";
import refundOrder from "../workflows/refund-order";

export default defineAgent({
  slug: "support",
  name: "Support",
  description: "Helps customers and can run the refund-order workflow.",
  systemPrompt:
    "Help customers. To issue a refund, call the refund-order tool with the order ID.",
  model: "openai/gpt-5.6-terra",
  tools: [refundOrder],
});

luno docs search "custom apps MCP"
luno integrations create --mcp https://mcp.deepwiki.com/mcp
luno connect my-org/deepwiki --print-url
luno integrations actions list my-org/deepwiki   # remote tools, not project TS actions yet
luno integrations execute my-org/deepwiki ask_question --input '{"repoName":"facebook/react","question":"…"}'
luno integrations sync my-org/deepwiki

import { defineAgent } from "@meetluno/luno/agent";
import { deepwiki } from "../integrations/deepwiki/integration";
// After authoring actions on `deepwiki` via app.action(...):

export default defineAgent({
  slug: "researcher",
  name: "Researcher",
  description: "Answers questions using the DeepWiki MCP app.",
  systemPrompt: "Use DeepWiki tools to answer repo questions.",
  model: "openai/gpt-5.6-sol",
  tools: [deepwiki], // all actions registered on the app
});

export default defineAction({
  slug: "issue-refund",
  name: "Issue refund",
  description: "Refund an order.",
  input: z.object({ orderId: z.string(), amount: z.number() }),
  output: z.object({ refundId: z.string() }),
  needsApproval: true,
  run: async ({ orderId, amount }) => refunds.create({ orderId, amount }),
});

luno agents approvals list <agent> <session-id>
luno agents approvals approve <agent> <session-id> <approval-id>
luno agents approvals deny <agent> <session-id> <approval-id> --reason "already refunded"

needsApproval: { editable: true },                          // anyone who may decide
needsApproval: { approvers: ["$owner"], editable: true },   // with approvers

curl -X POST "$LUNO_URL/agents/<agent>/sessions/<session-id>/approvals" \
  -H "content-type: application/json" \
  -d '{ "decisions": [
        { "approvalId": "a1", "decision": "approved" },
        { "approvalId": "a2", "decision": "approved", "editedInput": { "subject": "Fixed" } },
        { "approvalId": "a3", "decision": "denied", "reason": "duplicate" } ] }'

needsApproval: { approvers: ["finance-lead@acme.com", "cfo@acme.com"] },

// A personal assistant: whoever asked confirms the email before it is sent.
needsApproval: { approvers: ["$speaker", "$owner"] },

luno agents sessions signal <agent> <session-id> --message "Deploy finished: 12 tests passed"
luno agents sessions signal <agent> <session-id> --message "Stop, use staging" --mode inject

await client.agents.sendSignal("support", sessionId, { message: "Customer replied", mode: "queue" });
// → { woke: true } when the session was idle and a new turn started

luno agents prompt writer --message "Draft the launch post" --goal "A post under 200 words with a clear call to action"

await client.agents.prompt("writer", { message: "Draft the launch post", goal: "A post under 200 words with a CTA" });
const { session } = await client.agents.getSession("writer", sessionId);
// session.goal → { objective, status: "active" | "done" | "exhausted", runs, feedback }

defineAgent({
  // ...
  goal: { judge: "deepseek/deepseek-v4-flash-0731", maxRuns: 5 },
});

defineAgent({
  // ...
  goal: {
    judge: ({ goal, lastReply, messages }) =>
      lastReply.includes("CTA") ? { done: true } : { done: false, feedback: "Add a call to action." },
  },
});

import { defineSandbox } from "@meetluno/luno/sandbox";

export default defineAgent({
  slug: "support",
  name: "Support",
  description: "Answers using the support skill and attached product docs.",
  systemPrompt:
    "Read /workspace/agent/product-guide.md and the support skill before answering.",
  model: "openai/gpt-5.6-sol",
  skills: ["support"],
  sandbox: defineSandbox({ files: "support" }),
});

export default defineAgent({
  slug: "support",
  name: "Support",
  description: "Answers using the support handbook file set.",
  systemPrompt: "Read the support handbook before answering.",
  model: "openai/gpt-5.6-terra",
  sandbox: defineSandbox({ files: "support-handbook" }),
});

sandbox: defineSandbox({
  files: ["planetscale", "support/product-guide.md"],
}),

export default defineAgent({
  slug: "one-shot-classifier",
  name: "One-shot classifier",
  description: "Classifies a message and returns only the label.",
  systemPrompt: "Classify the message and return only the label.",
  model: "deepseek/deepseek-v4-flash",
  memory: false,
});

export default defineAgent({
  slug: "support",
  name: "Support",
  description: "Helps customers and remembers their setup.",
  systemPrompt: "Help the customer. Keep their account details current in your notes.",
  model: "openai/gpt-5.6-sol",
  memory: {
    workingMemory: {
      template: "# Customer\n- Name:\n- Plan:\n- Integrations:\n\n# Open issues\n",
    },
    semanticRecall: { topK: 5 },
  },
});

import { TokenLimiterProcessor, ToolCallFilter } from "@meetluno/luno/processors";

export default defineAgent({
  // ...
  inputProcessors: [
    new ToolCallFilter({ exclude: ["web_search"] }), // drop old search calls and results
    new TokenLimiterProcessor({ limit: 50_000 }), // cap the history sent per step
  ],
});

export default defineAgent({
  // ...
  memory: {
    observational: true, // or { model, messageTokens, observationTokens }
  },
});

export default defineAgent({
  slug: "researcher",
  name: "Researcher",
  description: "Researches questions and cites sources when available.",
  systemPrompt: "Research the user's question and cite sources when available.",
  model: "openai/gpt-5.6-sol",
});

export default defineAgent({
  slug: "planner",
  name: "Planner",
  description: "Plans carefully with higher reasoning effort.",
  systemPrompt: "Plan carefully, then give a concise answer.",
  model: "openai/gpt-5.6-terra",
  thinkingLevel: "high",
});

export default defineAgent({
  slug: "support",
  name: "Support",
  description: "Answers support questions.",
  systemPrompt: "Help the customer.",
  model: "anthropic/claude-sonnet-4.6",
  fallbackModels: ["openai/gpt-5.6-terra", "google/gemini-3.5-flash"],
});

export default defineAgent({
  slug: "coder",
  name: "Coder",
  description: "Plans and implements changes.",
  systemPrompt: "You work on the user's codebase.",
  model: "anthropic/claude-sonnet-5",
  tools: [searchDocs, openPullRequest],
  modes: {
    plan: {
      systemPrompt: "Plan only. Do not change files; end with a numbered plan.",
      model: "openai/gpt-5.6-sol",
      tools: ["search-docs"],
      thinkingLevel: "high",
    },
    build: {},
  },
  defaultMode: "plan",
});

import { defineAgent } from "@meetluno/luno/agent";
import {
  gatewayModel,
  PIIDetector,
  PromptInjectionDetector,
} from "@meetluno/luno/processors";

const checker = gatewayModel("deepseek/deepseek-v4-flash");

export default defineAgent({
  slug: "support",
  name: "Support",
  description: "Answers support questions.",
  systemPrompt: "Help the customer.",
  model: "anthropic/claude-sonnet-4.6",
  inputProcessors: [new PromptInjectionDetector({ model: checker, strategy: "block" })],
  outputProcessors: [new PIIDetector({ model: checker, strategy: "redact" })],
});

import { GuardBlockedError, gatewayModel, guardText } from "@meetluno/luno/processors";

const { text, findings } = await guardText(resumeText, {
  model: gatewayModel("deepseek/deepseek-v4-flash"),
  injection: "block", // or "detect": report only
  pii: "redact", // or "detect": report only, text unchanged
});

import { z } from "zod";
import researcher from "../agents/signup-researcher";

const Summary = z.object({ company: z.string(), summary: z.string() });

const result = await researcher.prompt({
  message: "Research Acme Corp",
  outputSchema: Summary,
});
if (result.error) throw new Error(result.error);

const { company, summary } = result.output!; // typed { company: string; summary: string }

curl -X POST "$LUNO_URL/agents/triage" -H "content-type: application/json" -d '{
  "message": "Login is broken for every user",
  "outputSchema": {
    "type": "object",
    "properties": { "priority": { "type": "string", "enum": ["low", "high"] } },
    "required": ["priority"]
  }
}'

const { sessionId } = await client.agents.prompt("triage", { message, outputSchema });
// …once the session is no longer running:
const { output } = await client.agents.getSession<{ priority: "low" | "high" }>("triage", sessionId);

luno agents prompt triage --message "Login is broken" --wait \
  --output-schema '{"type":"object","properties":{"priority":{"type":"string"}},"required":["priority"]}'
# or --output-schema-file ./triage-output.json; with --wait prints just the parsed output

const Decision = z.discriminatedUnion("action", [
  z.object({ action: z.literal("drop"), newPrice: z.number(), reasoning: z.string() }),
  z.object({ action: z.literal("no_more_offers"), reasoning: z.string() }),
  z.object({ action: z.literal("payment_plan"), months: z.number(), reasoning: z.string() }),
]);

export default defineAgent({
  slug: "web-researcher",
  name: "Web researcher",
  description: "Uses web search and fetch for current factual questions.",
  systemPrompt:
    "Use web_search before answering factual questions about current companies or events. Use web_fetch to inspect promising sources.",
  model: "google/gemini-3.5-flash",
});

luno agents workflows list <agent-slug>

import { defineAgent } from "@meetluno/luno/agent";
import { defineSandbox } from "@meetluno/luno/sandbox";

const seeded = defineSandbox({
  files: [{ path: "context/seed.txt", file: "seeded" }],
});

export default defineAgent({
  slug: "sandbox-seeded",
  name: "Sandbox seeded",
  description: "Reads seeded context files from the sandbox workspace.",
  systemPrompt: "Read files from /workspace/agent before answering.",
  model: "zai/glm-5.2",
  sandbox: seeded,
});

js-exec -c '
  const customer = await tools["lookup-customer"]({ email: "ada@example.com" });
  if (customer.openInvoices > 0) {
    await tools["send-reminder"]({ email: "ada@example.com" });
  }
'

export default defineAgent({
  slug: "repo-worker",
  name: "Repo worker",
  description: "Clones and edits repositories in a VM sandbox.",
  systemPrompt: "Clone the repo into /workspace/session, then make the requested change.",
  model: "openai/gpt-5.6-sol",
  sandbox: defineSandbox({ mode: "vm" }),
});

import { github } from "../integrations/github/integration";

sandbox: defineSandbox({
  mode: "vm",
  credentials: [github.credential] as const,
  env: ({ github }) => ({
    // Optional aliases — GH_TOKEN / GITHUB_TOKEN are injected automatically when `git` is set
    CUSTOM_GITHUB_TOKEN: github.accessToken,
  }),
  git: {
    clone: {
      repository: "owner/repo",
      credential: "github",
      // path defaults to /workspace/session/repo
      // branch: "main",          // optional branch or tag
      // commit: "abcdef01…",     // optional full 40-char SHA (takes precedence over branch)
      // shallow: false,          // default true (`--depth 1`); set false for full history
    },
  },
  setup: [
    "npm i -g @posthog/cli",
  ],
}),

sandbox: defineSandbox({
  mode: "vm",
  setup: [
    // CLIs (global / root-disk — not /workspace/agent)
    "npm i -g @posthog/cli",
    "curl -fsSL https://bun.sh/install | bash",
    // System packages
    "apt-get update && apt-get install -y jq ffmpeg",
    // Browsers / Playwright (default cache under $HOME — not /workspace/agent)
    "npx --yes playwright@1.49.0 install --with-deps chromium",
  ],
}),