@treeseed/sdk 0.1.1

package/dist/scripts/release-verify.js

@@ -0,0 +1,49 @@
+import { readFileSync, readdirSync } from 'node:fs';
+import { extname, join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { packageRoot } from './package-tools.js';
+const textExtensions = new Set(['.js', '.ts', '.mjs', '.cjs', '.d.js', '.json', '.md']);
+const forbiddenPatterns = [
+    /['"`]file:[^'"`\n]+['"`]/,
+    /['"`]workspace:[^'"`\n]+['"`]/,
+    /['"`](?:\.\.\/|\.\/)[^'"`\n]*src\/[^'"`\n]*\.(?:[cm]?js|ts|tsx|json|astro|css)['"`]/,
+    /['"`][^'"`\n]*\/packages\/[^'"`\n]*\/src\/[^'"`\n]*['"`]/,
+];
+function run(command, args) {
+    const result = spawnSync(command, args, {
+        cwd: packageRoot,
+        stdio: 'inherit',
+        env: process.env,
+    });
+    if (result.status !== 0) {
+        process.exit(result.status ?? 1);
+    }
+}
+function walkFiles(root) {
+    const files = [];
+    for (const entry of readdirSync(root, { withFileTypes: true })) {
+        const fullPath = join(root, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...walkFiles(fullPath));
+            continue;
+        }
+        files.push(fullPath);
+    }
+    return files;
+}
+function scanDirectory(root) {
+    for (const filePath of walkFiles(root)) {
+        if (!textExtensions.has(extname(filePath)))
+            continue;
+        const source = readFileSync(filePath, 'utf8');
+        for (const pattern of forbiddenPatterns) {
+            if (pattern.test(source)) {
+                throw new Error(`${filePath} contains forbidden publish reference matching ${pattern}.`);
+            }
+        }
+    }
+}
+run('npm', ['run', 'build:dist']);
+scanDirectory(resolve(packageRoot, 'dist'));
+run('npm', ['run', 'test:unit']);
+run('npm', ['run', 'test:smoke']);

package/dist/scripts/run-ts.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+
+import { build } from 'esbuild';
+import { readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+const [, , entryArg, ...scriptArgs] = process.argv;
+
+if (!entryArg) {
+	console.error('Usage: node ./scripts/run-ts.mjs <entry.ts> [...args]');
+	process.exit(1);
+}
+
+const cwd = process.cwd();
+const entryPath = resolve(cwd, entryArg);
+const outfile = resolve(
+	dirname(entryPath),
+	`.ts-run-${Date.now()}-${Math.random().toString(36).slice(2)}.js`,
+);
+
+try {
+	await build({
+		entryPoints: [entryPath],
+		outfile,
+		bundle: true,
+		format: 'esm',
+		platform: 'node',
+		packages: 'external',
+		sourcemap: 'inline',
+		logLevel: 'silent',
+	});
+
+	const builtSource = readFileSync(outfile, 'utf8');
+	writeFileSync(
+		outfile,
+		builtSource.replace(/(['"`])(\.[^'"`\n]+)\.ts\1/g, '$1$2.js$1'),
+		'utf8',
+	);
+
+	process.argv = [process.argv[0] ?? 'node', entryPath, ...scriptArgs];
+	await import(pathToFileURL(outfile).href);
+} finally {
+	rmSync(outfile, { force: true });
+}

package/dist/scripts/test-smoke.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/test-smoke.js

@@ -0,0 +1,77 @@
+import { mkdirSync, readdirSync, rmSync, symlinkSync, writeFileSync } from 'node:fs';
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { packageRoot } from './package-tools.js';
+function run(command, args, cwd = packageRoot, capture = false) {
+    const result = spawnSync(command, args, {
+        cwd,
+        stdio: capture ? 'pipe' : 'inherit',
+        encoding: 'utf8',
+        env: process.env,
+    });
+    if (result.status !== 0) {
+        throw new Error(result.stderr?.trim() || result.stdout?.trim() || `${command} ${args.join(' ')} failed`);
+    }
+    return (result.stdout ?? '').trim();
+}
+function resolveNodeModulesRoot() {
+    let lastCandidate = null;
+    let current = packageRoot;
+    while (true) {
+        const candidate = resolve(current, 'node_modules');
+        try {
+            readdirSync(candidate);
+            lastCandidate = candidate;
+        }
+        catch {
+        }
+        const parent = resolve(current, '..');
+        if (parent === current)
+            break;
+        current = parent;
+    }
+    if (lastCandidate) {
+        return lastCandidate;
+    }
+    throw new Error(`Unable to locate node_modules for ${packageRoot}.`);
+}
+function mirrorDependencies(tempRoot) {
+    const sharedNodeModules = resolveNodeModulesRoot();
+    for (const entry of readdirSync(sharedNodeModules, { withFileTypes: true })) {
+        if (entry.name === '.bin' || entry.name === '@treeseed') {
+            continue;
+        }
+        const targetPath = resolve(tempRoot, 'node_modules', entry.name);
+        mkdirSync(dirname(targetPath), { recursive: true });
+        symlinkSync(resolve(sharedNodeModules, entry.name), targetPath, 'dir');
+    }
+}
+const stageRoot = mkdtempSync(join(tmpdir(), 'treeseed-sdk-smoke-'));
+const packRoot = resolve(stageRoot, 'pack');
+const extractRoot = resolve(stageRoot, 'extract');
+const installRoot = resolve(stageRoot, 'install');
+try {
+    mkdirSync(packRoot, { recursive: true });
+    mkdirSync(extractRoot, { recursive: true });
+    const filename = run('npm', ['pack', '--silent', '--ignore-scripts', '--pack-destination', packRoot], packageRoot, true)
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .at(-1);
+    if (!filename) {
+        throw new Error('Unable to determine packed SDK tarball name.');
+    }
+    const tarballPath = resolve(packRoot, filename);
+    run('tar', ['-xzf', tarballPath, '-C', extractRoot]);
+    mkdirSync(resolve(installRoot, 'node_modules', '@treeseed'), { recursive: true });
+    run('cp', ['-R', resolve(extractRoot, 'package'), resolve(installRoot, 'node_modules', '@treeseed', 'sdk')]);
+    mirrorDependencies(installRoot);
+    writeFileSync(resolve(installRoot, 'package.json'), `${JSON.stringify({ name: 'treeseed-sdk-smoke', private: true, type: 'module' }, null, 2)}\n`, 'utf8');
+    run(process.execPath, ['--input-type=module', '-e', 'await import("@treeseed/sdk");'], installRoot);
+    console.log('SDK packed-install smoke passed.');
+}
+finally {
+    rmSync(stageRoot, { recursive: true, force: true });
+}

package/dist/sdk-filters.js

@@ -0,0 +1,77 @@
+function toArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value === void 0 || value === null) {
+    return [];
+  }
+  return [value];
+}
+function compareScalar(left, right) {
+  if (typeof left === "number" && typeof right === "number") {
+    return left - right;
+  }
+  return String(left ?? "").localeCompare(String(right ?? ""));
+}
+function getFieldValue(entry, field) {
+  if (field in entry) {
+    return entry[field];
+  }
+  if ("frontmatter" in entry && entry.frontmatter && typeof entry.frontmatter === "object") {
+    return entry.frontmatter[field];
+  }
+  return void 0;
+}
+function matchesFilter(entry, filter) {
+  const fieldValue = getFieldValue(entry, filter.field);
+  switch (filter.op) {
+    case "eq":
+      return fieldValue === filter.value;
+    case "in":
+      return toArray(filter.value).includes(fieldValue);
+    case "contains":
+      if (Array.isArray(fieldValue)) {
+        return fieldValue.includes(filter.value);
+      }
+      return String(fieldValue ?? "").toLowerCase().includes(String(filter.value ?? "").toLowerCase());
+    case "prefix":
+      return String(fieldValue ?? "").toLowerCase().startsWith(String(filter.value ?? "").toLowerCase());
+    case "gt":
+      return compareScalar(fieldValue, filter.value) > 0;
+    case "gte":
+      return compareScalar(fieldValue, filter.value) >= 0;
+    case "lt":
+      return compareScalar(fieldValue, filter.value) < 0;
+    case "lte":
+      return compareScalar(fieldValue, filter.value) <= 0;
+    case "updated_since":
+      return new Date(String(fieldValue ?? 0)).valueOf() >= new Date(String(filter.value)).valueOf();
+    case "related_to":
+      return Array.isArray(fieldValue) && fieldValue.includes(filter.value);
+    default:
+      return false;
+  }
+}
+function applyFilters(items, filters = []) {
+  return items.filter((item) => filters.every((filter) => matchesFilter(item, filter)));
+}
+function applySort(items, sort = []) {
+  if (sort.length === 0) {
+    return items;
+  }
+  return [...items].sort((left, right) => {
+    for (const spec of sort) {
+      const direction = spec.direction === "asc" ? 1 : -1;
+      const comparison = compareScalar(getFieldValue(left, spec.field), getFieldValue(right, spec.field));
+      if (comparison !== 0) {
+        return comparison * direction;
+      }
+    }
+    return 0;
+  });
+}
+export {
+  applyFilters,
+  applySort,
+  matchesFilter
+};

package/dist/sdk-types.js

@@ -0,0 +1,24 @@
+const SDK_MODEL_NAMES = [
+  "page",
+  "note",
+  "question",
+  "book",
+  "knowledge",
+  "objective",
+  "person",
+  "subscription",
+  "message",
+  "agent",
+  "agent_run",
+  "agent_cursor",
+  "content_lease"
+];
+const SDK_OPERATIONS = ["get", "read", "search", "follow", "pick", "create", "update"];
+const SDK_STORAGE_BACKENDS = ["content", "d1"];
+const SDK_PICK_STRATEGIES = ["latest", "highest_priority", "oldest"];
+export {
+  SDK_MODEL_NAMES,
+  SDK_OPERATIONS,
+  SDK_PICK_STRATEGIES,
+  SDK_STORAGE_BACKENDS
+};

package/dist/sdk.js

@@ -0,0 +1,232 @@
+import { resolveSdkRepoRoot } from "./runtime.js";
+import { normalizeAgentCliOptions } from "./cli-tools.js";
+import { ContentStore } from "./content-store.js";
+import { CloudflareD1AgentDatabase, MemoryAgentDatabase } from "./d1-store.js";
+import { resolveModelDefinition } from "./model-registry.js";
+import { WranglerD1Database } from "./wrangler-d1.js";
+function normalizeAgentSpec(entry) {
+  if (!entry) {
+    return null;
+  }
+  const frontmatter = entry.frontmatter ?? {};
+  return {
+    ...frontmatter,
+    slug: String(frontmatter.slug ?? entry.slug ?? ""),
+    cli: normalizeAgentCliOptions(frontmatter.cli)
+  };
+}
+function normalizeOperation(operation) {
+  return operation === "read" ? "get" : operation;
+}
+function operationAllowed(permissions, model, operation) {
+  const normalizedOperation = normalizeOperation(operation);
+  return permissions.some(
+    (permission) => permission.model === model && permission.operations.map(normalizeOperation).includes(normalizedOperation)
+  );
+}
+class AgentSdk {
+  database;
+  content;
+  constructor(options = {}) {
+    const repoRoot = resolveSdkRepoRoot(options.repoRoot);
+    this.database = options.database ?? new MemoryAgentDatabase();
+    this.content = new ContentStore(repoRoot, this.database);
+  }
+  static createLocal(options) {
+    const repoRoot = resolveSdkRepoRoot(options.repoRoot);
+    const d1 = new WranglerD1Database(
+      options.databaseName ?? "karyon-docs-site-data",
+      repoRoot,
+      options.persistTo
+    );
+    return new AgentSdk({
+      repoRoot,
+      database: new CloudflareD1AgentDatabase(d1)
+    });
+  }
+  envelope(model, operation, payload, meta) {
+    return {
+      ok: true,
+      model: resolveModelDefinition(model).name,
+      operation,
+      payload,
+      meta
+    };
+  }
+  async get(request) {
+    const definition = resolveModelDefinition(request.model);
+    const payload = definition.storage === "content" ? await this.content.get({ ...request, model: definition.name }) : await this.database.get({ ...request, model: definition.name });
+    return this.envelope(definition.name, "get", payload);
+  }
+  read(request) {
+    return this.get(request).then((response) => ({
+      ...response,
+      operation: "read"
+    }));
+  }
+  async search(request) {
+    const definition = resolveModelDefinition(request.model);
+    const payload = definition.storage === "content" ? await this.content.search({ ...request, model: definition.name }) : await this.database.search({ ...request, model: definition.name });
+    return this.envelope(definition.name, "search", payload, {
+      count: Array.isArray(payload) ? payload.length : 0
+    });
+  }
+  async follow(request) {
+    const definition = resolveModelDefinition(request.model);
+    const payload = definition.storage === "content" ? await this.content.follow({ ...request, model: definition.name }) : await this.database.follow({ ...request, model: definition.name });
+    return this.envelope(definition.name, "follow", payload, {
+      count: payload.items.length
+    });
+  }
+  async pick(request) {
+    const definition = resolveModelDefinition(request.model);
+    const payload = definition.storage === "content" ? await this.content.pick({ ...request, model: definition.name }) : await this.database.pick({ ...request, model: definition.name });
+    return this.envelope(definition.name, "pick", payload, {
+      claimed: Boolean(payload.item)
+    });
+  }
+  async create(request) {
+    const definition = resolveModelDefinition(request.model);
+    const payload = definition.storage === "content" ? await this.content.create({ ...request, model: definition.name }) : await this.database.create({ ...request, model: definition.name });
+    return this.envelope(definition.name, "create", payload);
+  }
+  async update(request) {
+    const definition = resolveModelDefinition(request.model);
+    const payload = definition.storage === "content" ? await this.content.update({ ...request, model: definition.name }) : await this.database.update({ ...request, model: definition.name });
+    return this.envelope(definition.name, "update", payload);
+  }
+  async claimMessage(request) {
+    const payload = await this.database.claimMessage(request);
+    return this.envelope("message", "pick", payload, {
+      claimed: Boolean(payload)
+    });
+  }
+  async ackMessage(request) {
+    await this.database.ackMessage(request);
+    return this.envelope("message", "update", { id: request.id, status: request.status });
+  }
+  async createMessage(request) {
+    const payload = await this.database.createMessage(request);
+    return this.envelope("message", "create", payload);
+  }
+  async recordRun(request) {
+    const payload = await this.database.recordRun(request);
+    return this.envelope("agent_run", "update", payload);
+  }
+  async getCursor(request) {
+    const payload = await this.database.getCursor(request);
+    return this.envelope("agent_cursor", "get", payload);
+  }
+  async upsertCursor(request) {
+    await this.database.upsertCursor(request);
+    return this.envelope("agent_cursor", "update", request);
+  }
+  async releaseLease(request) {
+    await this.database.releaseLease(request);
+    return this.envelope("content_lease", "update", request);
+  }
+  async releaseAllLeases() {
+    const count = await this.database.releaseAllLeases();
+    return this.envelope("content_lease", "update", { count });
+  }
+  async listAgentSpecs(options) {
+    const rawEntries = await this.listRawAgentSpecs(options);
+    return rawEntries.map((entry) => normalizeAgentSpec(entry)).filter((entry) => Boolean(entry && entry.slug));
+  }
+  async listRawAgentSpecs(options) {
+    const filters = typeof options?.enabled === "boolean" ? [{ field: "enabled", op: "eq", value: options.enabled }] : [];
+    const response = await this.search({
+      model: "agent",
+      filters,
+      sort: [{ field: "name", direction: "asc" }]
+    });
+    return response.payload;
+  }
+  scopeForAgent(agent) {
+    return new ScopedAgentSdk(this, agent.slug, agent.permissions);
+  }
+}
+class ScopedAgentSdk {
+  constructor(base, actor, permissions) {
+    this.base = base;
+    this.actor = actor;
+    this.permissions = permissions;
+  }
+  base;
+  actor;
+  permissions;
+  assertAllowed(model, operation) {
+    const normalized = resolveModelDefinition(model).name;
+    if (!operationAllowed(this.permissions, normalized, operation)) {
+      throw new Error(`Agent "${this.actor}" is not allowed to ${operation} ${normalized}.`);
+    }
+  }
+  get(request) {
+    this.assertAllowed(request.model, "get");
+    return this.base.get(request);
+  }
+  read(request) {
+    this.assertAllowed(request.model, "read");
+    return this.base.read(request);
+  }
+  search(request) {
+    this.assertAllowed(request.model, "search");
+    return this.base.search(request);
+  }
+  follow(request) {
+    this.assertAllowed(request.model, "follow");
+    return this.base.follow(request);
+  }
+  pick(request) {
+    this.assertAllowed(request.model, "pick");
+    return this.base.pick(request);
+  }
+  create(request) {
+    this.assertAllowed(request.model, "create");
+    return this.base.create({
+      ...request,
+      actor: this.actor
+    });
+  }
+  update(request) {
+    this.assertAllowed(request.model, "update");
+    return this.base.update({
+      ...request,
+      actor: this.actor
+    });
+  }
+  claimMessage(request) {
+    this.assertAllowed("message", "pick");
+    return this.base.claimMessage(request);
+  }
+  ackMessage(request) {
+    this.assertAllowed("message", "update");
+    return this.base.ackMessage(request);
+  }
+  createMessage(request) {
+    this.assertAllowed("message", "create");
+    return this.base.createMessage({
+      ...request,
+      actor: this.actor
+    });
+  }
+  recordRun(request) {
+    return this.base.recordRun(request);
+  }
+  getCursor(request) {
+    return this.base.getCursor(request);
+  }
+  upsertCursor(request) {
+    return this.base.upsertCursor(request);
+  }
+  releaseLease(request) {
+    return this.base.releaseLease(request);
+  }
+  releaseAllLeases() {
+    return this.base.releaseAllLeases();
+  }
+}
+export {
+  AgentSdk,
+  ScopedAgentSdk
+};

package/dist/src/cli-tools.d.ts

@@ -0,0 +1,3 @@
+import { type AgentCliOptions } from './types/agents.ts';
+export declare function normalizeAgentCliOptions(input: unknown): AgentCliOptions;
+export declare function buildCopilotAllowToolArgs(allowTools?: AgentCliOptions['allowTools']): string[];

package/dist/src/content-store.d.ts

@@ -0,0 +1,24 @@
+import type { SdkContentEntry, SdkFollowRequest, SdkGetRequest, SdkMutationRequest, SdkPickRequest, SdkPickResult, SdkSearchRequest, SdkUpdateRequest } from './sdk-types.ts';
+import type { AgentDatabase } from './d1-store.ts';
+export declare class ContentStore {
+    private readonly repoRoot;
+    private readonly database;
+    private readonly gitRuntime;
+    constructor(repoRoot: string, database: AgentDatabase);
+    list(model: string): Promise<SdkContentEntry[]>;
+    get(request: SdkGetRequest): Promise<SdkContentEntry | null>;
+    search(request: SdkSearchRequest): Promise<SdkContentEntry[]>;
+    follow(request: SdkFollowRequest): Promise<{
+        items: SdkContentEntry[];
+        since: string;
+    }>;
+    pick(request: SdkPickRequest): Promise<SdkPickResult<SdkContentEntry>>;
+    create(request: SdkMutationRequest): Promise<{
+        item: SdkContentEntry;
+        git: import("./git-runtime.ts").GitMutationResult;
+    }>;
+    update(request: SdkUpdateRequest): Promise<{
+        item: SdkContentEntry;
+        git: import("./git-runtime.ts").GitMutationResult;
+    }>;
+}

package/dist/src/d1-store.d.ts

@@ -0,0 +1,108 @@
+import type { ContentLeaseRecord } from './types/agents.ts';
+import type { D1DatabaseLike } from './types/cloudflare.ts';
+import type { SdkAckMessageRequest, SdkClaimMessageRequest, SdkCreateMessageRequest, SdkCursorEntity, SdkCursorRequest, SdkFollowRequest, SdkGetRequest, SdkGetCursorRequest, SdkLeaseEntity, SdkLeaseReleaseRequest, SdkMessageEntity, SdkMutationRequest, SdkPickRequest, SdkPickResult, SdkRecordRunRequest, SdkRunEntity, SdkSearchRequest, SdkSubscriptionEntity, SdkUpdateRequest } from './sdk-types.ts';
+import { type LeaseClaimInput } from './stores/lease-store.ts';
+export interface TryClaimContentLeaseInput extends LeaseClaimInput {
+}
+export interface AgentDatabase {
+    get(request: SdkGetRequest): Promise<Record<string, unknown> | null>;
+    search(request: SdkSearchRequest): Promise<Record<string, unknown>[]>;
+    follow(request: SdkFollowRequest): Promise<{
+        items: Record<string, unknown>[];
+        since: string;
+    }>;
+    pick(request: SdkPickRequest): Promise<SdkPickResult<Record<string, unknown>>>;
+    create(request: SdkMutationRequest): Promise<Record<string, unknown>>;
+    update(request: SdkUpdateRequest): Promise<Record<string, unknown> | null>;
+    claimMessage(request: SdkClaimMessageRequest): Promise<SdkMessageEntity | null>;
+    ackMessage(request: SdkAckMessageRequest): Promise<void>;
+    createMessage(request: SdkCreateMessageRequest): Promise<SdkMessageEntity>;
+    recordRun(request: SdkRecordRunRequest): Promise<Record<string, unknown>>;
+    getCursor(request: SdkGetCursorRequest): Promise<string | null>;
+    upsertCursor(request: SdkCursorRequest): Promise<void>;
+    releaseLease(request: SdkLeaseReleaseRequest): Promise<void>;
+    tryClaimContentLease(input: TryClaimContentLeaseInput): Promise<string | null>;
+    releaseAllLeases(): Promise<number>;
+}
+export declare class MemoryAgentDatabase implements AgentDatabase {
+    private readonly subscriptions;
+    private readonly messages;
+    private readonly runs;
+    private readonly contentLeases;
+    private readonly cursors;
+    private messageId;
+    constructor(seed?: {
+        subscriptions?: SdkSubscriptionEntity[];
+        messages?: SdkMessageEntity[];
+        runs?: SdkRunEntity[];
+        cursors?: SdkCursorEntity[];
+        leases?: SdkLeaseEntity[];
+    });
+    private rowsForModel;
+    get(request: SdkGetRequest): Promise<Record<string, unknown> | null>;
+    search(request: SdkSearchRequest): Promise<Record<string, unknown>[]>;
+    follow(request: SdkFollowRequest): Promise<{
+        items: Record<string, unknown>[];
+        since: string;
+    }>;
+    pick(request: SdkPickRequest): Promise<SdkPickResult<Record<string, unknown>>>;
+    create(request: SdkMutationRequest): Promise<Record<string, unknown>>;
+    update(request: SdkUpdateRequest): Promise<Record<string, unknown> | {
+        updated_at: string;
+        id?: number;
+        recordType?: import("./sdk-types.ts").TreeseedRuntimeRecordType;
+        schemaVersion?: import("./sdk-types.ts").TreeseedSchemaVersion;
+        email: string;
+        name?: string | null;
+        status: string;
+        source?: string;
+        metaJson?: string;
+        consent_at?: string;
+        created_at?: string;
+        ip_hash?: string;
+    } | null>;
+    claimMessage(request: SdkClaimMessageRequest): Promise<SdkMessageEntity | null>;
+    ackMessage(request: SdkAckMessageRequest): Promise<void>;
+    createMessage(request: SdkCreateMessageRequest): Promise<SdkMessageEntity>;
+    recordRun(request: SdkRecordRunRequest): Promise<SdkRunEntity>;
+    getCursor(request: SdkGetCursorRequest): Promise<string | null>;
+    upsertCursor(request: SdkCursorRequest): Promise<void>;
+    releaseLease(request: SdkLeaseReleaseRequest): Promise<void>;
+    tryClaimContentLease(input: TryClaimContentLeaseInput): Promise<`${string}-${string}-${string}-${string}-${string}` | null>;
+    releaseAllLeases(): Promise<number>;
+    inspectRuns(): SdkRunEntity[];
+    inspectLeases(): ContentLeaseRecord[];
+}
+export declare class CloudflareD1AgentDatabase implements AgentDatabase {
+    readonly db: D1DatabaseLike;
+    private readonly subscriptions;
+    private readonly messages;
+    private readonly runs;
+    private readonly cursors;
+    private readonly leases;
+    constructor(db: D1DatabaseLike);
+    get(request: SdkGetRequest): Promise<Record<string, unknown> | null>;
+    search(request: SdkSearchRequest): Promise<Record<string, unknown>[]>;
+    follow(request: SdkFollowRequest): Promise<{
+        items: Record<string, unknown>[];
+        since: string;
+    }>;
+    pick(request: SdkPickRequest): Promise<{
+        item: Record<string, unknown> | null;
+        leaseToken: `${string}-${string}-${string}-${string}-${string}` | null;
+    } | {
+        item: Record<string, unknown> | null;
+        leaseToken: string;
+    }>;
+    create(request: SdkMutationRequest): Promise<Record<string, unknown>>;
+    update(request: SdkUpdateRequest): Promise<Record<string, unknown> | null>;
+    claimMessage(request: SdkClaimMessageRequest): Promise<SdkMessageEntity | null>;
+    ackMessage(request: SdkAckMessageRequest): Promise<void>;
+    createMessage(request: SdkCreateMessageRequest): Promise<SdkMessageEntity>;
+    recordRun(request: SdkRecordRunRequest): Promise<SdkRunEntity>;
+    getCursor(request: SdkGetCursorRequest): Promise<string | null>;
+    upsertCursor(request: SdkCursorRequest): Promise<void>;
+    releaseLease(request: SdkLeaseReleaseRequest): Promise<void>;
+    tryClaimContentLease(input: TryClaimContentLeaseInput): Promise<`${string}-${string}-${string}-${string}-${string}` | null>;
+    releaseAllLeases(): Promise<number>;
+}

package/dist/src/frontmatter.d.ts

@@ -0,0 +1,6 @@
+export interface ParsedMarkdownDocument {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export declare function parseFrontmatterDocument(source: string): ParsedMarkdownDocument;
+export declare function serializeFrontmatterDocument(frontmatter: Record<string, unknown>, body: string): string;

package/dist/src/git-runtime.d.ts

@@ -0,0 +1,16 @@
+export interface GitMutationResult {
+    branchName: string;
+    commitMessage: string;
+    worktreePath: string;
+    commitSha: string | null;
+    changedPaths: string[];
+}
+export declare class GitRuntime {
+    private readonly repoRoot;
+    private readonly disabled;
+    constructor(repoRoot: string, disabled?: boolean);
+    currentBranch(): Promise<string>;
+    ensureWorktree(branchName: string): Promise<string>;
+    commitFileChange(filePath: string, branchName: string, commitMessage: string): Promise<GitMutationResult>;
+    commitFileChanges(filePaths: string[], branchName: string, commitMessage: string): Promise<GitMutationResult>;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export { AgentSdk, ScopedAgentSdk } from './sdk.ts';
+export { MODEL_REGISTRY, buildModelRegistry, resolveModelDefinition } from './model-registry.ts';
+export { normalizeAgentCliOptions, buildCopilotAllowToolArgs } from './cli-tools.ts';
+export type { SdkContentEntry, SdkCursorEntity, SdkFilterCondition, SdkFollowRequest, SdkGetRequest, SdkJsonEnvelope, SdkLeaseEntity, SdkMessageEntity, SdkModelDefinition, SdkModelName, SdkMutationRequest, SdkOperation, SdkPickRequest, SdkPickResult, SdkRunEntity, SdkSearchRequest, SdkSubscriptionEntity, SdkUpdateRequest, } from './sdk-types.ts';
+export type { AgentDatabase } from './d1-store.ts';
+export type { D1DatabaseLike, D1PreparedStatementLike } from './types/cloudflare.ts';