Headless agents with the default import

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

export default defineAgent<{ message: string }>({
  name: 'echo', triggers: { webhook: true },
  run: async ({ init, input }) => {
    const session = await (await init({ model: 'openai/gpt-5.5' })).session();
    return { reply: await session.prompt<string>(input.message) };
  },
});

export FABRIC_MODEL=openai/gpt-5.5
export OPENAI_API_KEY=...
fabric-harness run echo --message "hello"

fabric-harness dev
curl -X POST http://localhost:3000/jobs/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';

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

---
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';

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

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

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';

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

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

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

export default defineAgent<{ prompt?: string }>({
  name: 'gh-assist',
  run: async ({ init, input, 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(input.prompt ?? '');
    } finally {
      await github.close();
    }
  },
});

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

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

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

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 defineAgent({
  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;
  },
});