Headless agents with the Lite SDK

import { defineAgent } from '@fabric-harness/sdk/lite';

export default defineAgent(async ({ init, payload }) => {
  const agent = await init({ runtime: 'stateless' });
  const session = await agent.session();
  const message = (payload as { message?: string })?.message ?? 'Say hi.';
  return { reply: await session.prompt<string>(message) };
}, { name: 'echo', triggers: { webhook: true } });

export FABRIC_MODEL=anthropic/claude-sonnet-4-6
export ANTHROPIC_API_KEY=...
fabric-harness run echo --message "hello"

fabric-harness dev
curl -X POST http://localhost:8787/agents/echo \
  -H "Content-Type: application/json" \
  -d '{"message":"hello"}'

---
name: triager
description: Search the knowledge base for the best matching article and write a concise, friendly reply.
---

You are a customer support triager.

Steps:
1. Use grep / glob / read over `/workspace/kb` to find articles relevant to the customer's question.
2. Quote the most directly relevant lines.
3. Write a 2–4 sentence reply in the brand's voice (friendly, concise, no jargon).
4. If nothing matches, say so honestly and suggest the customer contact support@example.com.

import { defineAgent } from '@fabric-harness/sdk/lite';

export default defineAgent(async ({ init, payload }) => {
  const session = await (await init({ runtime: 'stateless' })).session();
  const message = String((payload as any)?.message ?? '');
  const reply = await session.skill<string>('triager', { args: { message } });
  return { reply };
}, { name: 'support', triggers: { webhook: true } });

---
name: concise
description: Reply in 1-3 sentences. No bullet points unless explicitly asked. Plain prose only.
---

You write extremely concise replies. Aim for 1–3 sentences. Use plain prose,
not bullet points or headings, unless the user asked for structured output.
Never repeat the question back. Never apologize for the length of the answer.

const session = await agent.session('thread-1', { role: 'concise' });
await session.prompt('What does this code do?');           // uses 'concise'
await session.skill('triager', { args, role: 'concise' }); // override on the call

import { defineAgent, defineCommand } from '@fabric-harness/sdk/lite';

const gh = defineCommand('gh', { env: { GH_TOKEN: process.env.GH_TOKEN } });
const npm = defineCommand('npm');

export default defineAgent(async ({ init, payload }) => {
  const session = await (await init({ sandbox: 'local', runtime: 'stateless' })).session();
  const result = await session.skill<string>('triage-issue', {
    args: { issueNumber: (payload as any)?.issueNumber },
    commands: [gh, npm],   // available only inside this skill call
  });
  return { result };
}, { name: 'triage' });

const research = await session.task('Read /workspace/kb/billing/* and summarize the refund policy in 5 bullets.');
const reply    = await session.prompt(`Use this research to answer the customer:\n\n${research}`);

import { defineAgent, localDirectorySource, withFilesystemSources } from '@fabric-harness/sdk/lite';

const sandbox = withFilesystemSources('empty', [{
  mountAt: '/workspace/kb',
  source: localDirectorySource('./knowledge-base', { include: (p) => p.endsWith('.md') }),
}]);

export default defineAgent(async ({ init, payload }) => {
  const session = await (await init({ sandbox, runtime: 'stateless' })).session();
  const reply = await session.skill<string>('triager', {
    args: { message: String((payload as any)?.message ?? '') },
  });
  return { reply };
}, { name: 'support', triggers: { webhook: true } });

import { connectMcpServer, defineAgent } from '@fabric-harness/sdk/lite';

export default defineAgent(async ({ init, payload, env }) => {
  const github = await connectMcpServer('github', {
    url: 'https://mcp.github.com/mcp',
    headers: { Authorization: `Bearer ${env?.GITHUB_TOKEN}` },
  });
  try {
    const session = await (await init({ tools: github.tools, runtime: 'stateless' })).session();
    return await session.prompt(String((payload as any)?.prompt ?? ''));
  } finally {
    await github.close();
  }
}, { name: 'gh-assist' });

import { defineAgent } from '@fabric-harness/sdk/lite';

export default defineAgent(async ({ init, payload }) => {
  const session = await (await init({ runtime: 'stateless' })).session();
  return { reply: await session.prompt<string>(String((payload as any)?.message)) };
}, { name: 'echo' });

import { agent, schema } from '@fabric-harness/sdk';
import type { CapabilityPolicy } from '@fabric-harness/sdk';

const policy: CapabilityPolicy = {
  commandPolicy: {
    allow: ['git status*', 'git diff*'],
    deny: ['git push*'],
    requireApproval: ['gh issue comment**'],
  },
  maxCommandTimeoutMs: 30_000,
};

const inputSchema = schema.object({ issueNumber: schema.number(), title: schema.string() });
const outputSchema = schema.object({ severity: schema.enum(['low','medium','high']), summary: schema.string() });

export default agent({
  name: 'triage',
  input: inputSchema,
  output: outputSchema,
  model: process.env.FABRIC_MODEL,
  skills: [{ name: 'triage', content: 'Triage the issue and return a concise structured result.' }],
  run: async ({ init, input }) => {
    const session = await (await init({ policy })).session();
    const result = await session.skill('triage', { args: input, policy, result: outputSchema });
    await session.artifact('triage.md', `# ${input.title}`, { contentType: 'text/markdown' });
    return result;
  },
});