@lumifai/harness 0.0.1

package/README.md

@@ -0,0 +1,368 @@
+# @lumifai/harness
+
+Lumif's thin harness factory around Mastra's `AgentController` runtime. The controller is shared;
+each conversation is owned by a Mastra `Session`. Server integrations add scoped identity,
+durable lifecycle, reconnect, and transport behavior.
+
+## Layered install
+
+1. **Core** — `@lumifai/harness`, `@lumifai/harness-protocol`
+2. **Presets** — `@lumifai/harness-presets`
+3. **Tool packs** — individual `@lumifai/harness-tool-pack-*` packages
+4. **Server** — `@lumifai/harness-server`, `@lumifai/harness-server-fastify`, `@lumifai/harness-server-nest`
+5. **Client / React** — `@lumifai/harness-client`, `@lumifai/harness-react`, `@lumifai/harness-react-mantine`
+
+## Usage
+
+```typescript
+import { LibSQLStore } from '@mastra/libsql';
+import { createLumifHarness } from '@lumifai/harness';
+import { createPresetHarnessConfig, createPresetWorkspace } from '@lumifai/harness-presets';
+
+const presets = createPresetHarnessConfig({
+  includeRequestAccess: true,
+});
+
+const controller = createLumifHarness({
+  id: 'my-service-agent',
+  storage: new LibSQLStore({ url: 'file:./data.db' }),
+  workspace: createPresetWorkspace({
+    workspaceMode: 'local',
+    sandboxEnabled: true,
+  }),
+  modes: presets.modes,
+  subagents: presets.subagents,
+  tools: presets.tools,
+});
+
+await controller.init();
+const session = await controller.createSession({
+  id: 'session-1',
+  ownerId: 'user-1',
+  resourceId: 'resource-1',
+});
+await session.sendMessage({ content: 'Hello!' });
+```
+
+`workspace` is required. Everything else is forwarded to Mastra's harness and can be overridden as needed.
+
+## Production defaults
+
+The server wrapper in `@lumifai/harness-server` makes persistence and tenancy explicit:
+
+- `storage` defaults to a local LibSQL file store under the workspace path
+- `memory` defaults to `new Memory({ storage })`, but you can pass any Mastra memory or a factory
+- `threadLock` can be supplied for multi-pod / multi-process coordination
+- `contextResolver` lets adapters inject `tenantId`, `userId`, `resourceId`, `sessionId`, `threadId`, and arbitrary request context
+- `authorize` lets adapters enforce route-level access control before state changes or reads
+- `allowClientResourceId` is `false` by default so resource scope comes from server context, not the browser
+- `/healthz` and `/readyz` are exposed by the Fastify server
+
+## Workspace modes
+
+`createPresetWorkspace()` and `createHarnessServerWorkspace()` make the workspace shape explicit:
+
+- `workspaceMode: 'local'` - `LocalFilesystem` plus optional `LocalSandbox`
+- `workspaceMode: 'filesystem'` - a single filesystem provider, no sandbox
+- `workspaceMode: 'mounts'` - mount-backed workspace for sandbox-visible cloud storage
+
+`filesystem` and `mounts` are mutually exclusive. Use `mounts` when the sandbox must see cloud storage paths directly.
+
+Sandbox is off by default. In local mode, set `sandboxEnabled: true` to attach a `LocalSandbox` whose `workingDirectory` matches the `LocalFilesystem` `basePath`. You can also pass a custom `sandbox` or tune local sandbox settings via `localSandboxOptions`.
+
+Mount-backed example for cloud storage visible inside the sandbox:
+
+```typescript
+import { LocalSandbox } from '@mastra/core/workspace';
+
+createPresetWorkspace({
+  workspaceMode: 'mounts',
+  mounts: { '/data': myCloudFilesystem },
+  sandbox: new LocalSandbox({ workingDirectory: './workspace' }),
+});
+```
+
+## Persistence and resume
+
+The server integration uses two Mastra storage layers:
+
+- Mastra's `harness` domain stores one scoped session record containing tenant/owner/resource
+  identity, the active thread, mode/model, configuration, lifecycle status, and all pending native
+  suspensions.
+- Mastra memory/thread storage remains the source of truth for messages, threads, and AgentController
+  state. The session record is a registry and lifecycle index, not a second message store.
+
+The external `sessionId` is a client handle. The durable record ID is a versioned SHA-256 scope key
+over tenant, owner, resource, and external session ID, so identical browser IDs cannot collide
+across users or tenants. Explicit destroy deletes owned threads and soft-deletes the record with
+`deletedAt`; storage retention/pruning handles physical cleanup.
+
+Tool _approvals_ are intentionally **not** persisted: the approval gate is an in-memory parked promise that does not survive a restart, so a pending approval is resolvable only within the live process. Interactive tool _suspensions_ (`ask_user`, `submit_plan`, `request_access`) are the durable, resumable primitive.
+
+Resume flow:
+
+1. A request comes in with `sessionId`
+2. `HarnessSessionManager` derives the trusted scope and looks up the harness record directly
+3. A fresh `HarnessSession` is created on the current pod
+4. The harness is reattached to the persisted `threadId` and `resourceId`
+5. Every persisted native suspension is re-registered from the record
+6. SSE/event subscriptions attach to the new in-memory session instance
+
+This is what makes the harness resumable across pods. Pod-local memory is not the source of truth.
+
+Display state and SSE events include `currentRunId` plus an array of pending suspensions. Each item
+has its own `toolCallId` and optional `runId`, so parallel human-input prompts can be rendered and
+resumed independently.
+
+Mastra approvals are deliberately process-local. If a process dies while an approval is parked,
+the next runtime reports the session as `interrupted`; an old approval response cannot be replayed.
+Native tool suspensions are the durable human-input primitive.
+
+While a session is running, `sendMessage` starts a normal run, `followUp` queues input behind the
+current run, and `steer` aborts the current run and redirects it. A session waiting on native input
+does not keep a model process alive: it can be evicted from the in-memory LRU and reconstructed
+when the user returns minutes or days later.
+
+## Human-in-the-loop tools
+
+Lumif presets replace Mastra's built-in `ask_user` and `submit_plan` with host-owned versions
+(same tool ids) and disable those builtins via `disableBuiltinTools`:
+
+- `ask_user` — free-text or choice questions, including `selectionMode`. Coerces free-form mistakes
+  (`selectionMode` without options) into a real free-text suspend instead of Mastra's soft failure
+- `submit_plan` — plan review and approval in plan mode
+- `request_access` — sandbox directory access prompts (only when `includeRequestAccess: true` and the workspace exposes a `LocalFilesystem`)
+
+All interactive flows suspend via Mastra's tool suspension API instead of ad-hoc harness events.
+Presets keep `autoResumeSuspendedTools` off so the host (Studio / API
+`respondToToolSuspension`) owns resumes — Mastra's auto-resume path otherwise coaches the model
+to stuff `resumeData` into tool-call arguments. Lumif keeps the public
+`{ answer: string | string[] }` response shape for `ask_user` and converts it to Mastra's native
+resume value at the server boundary.
+
+The server disables Mastra builtins for each same-id preset tool that is registered. Turn a tool
+off entirely with `toolToggles.ask_user = false` (also disables the Mastra builtin).
+
+Studio treats empty options and single “Use free text” proxy choices as a textarea so free-form
+questions still render correctly when the model mis-shapes the payload.
+
+## Server integration
+
+Use `@lumifai/harness-server` with Fastify or NestJS adapters. Boot config owns workspace shape, tool packs, and permission rules:
+
+```typescript
+import { createHarnessSessionManager } from '@lumifai/harness-server';
+// Fastify: harnessFastifyPlugin from '@lumifai/harness-server-fastify'
+// NestJS: HarnessModule from '@lumifai/harness-server-nest'
+
+createHarnessSessionManager({
+  bootConfig: {
+    workspaceBasePath: './workspace',
+    workspaceMode: 'local',
+    sandboxEnabled: true,
+    storage: new LibSQLStore({ url: 'file:/absolute/path/to/harness.db' }),
+    threadLock: {
+      acquire: async ({ threadId }) => {
+        /* distributed lock */
+      },
+      release: async ({ threadId }) => {
+        /* distributed unlock */
+      },
+    },
+    toolPacks: [
+      /* ... */
+    ],
+    permissionRules: { categories: { execute: 'ask' } },
+  },
+});
+```
+
+Built-in workspace boot options (ignored when `workspace` is provided):
+
+- `workspaceMode` — `'local' | 'filesystem' | 'mounts'`
+- `workspaceFilesystem` — custom filesystem provider
+- `workspaceMounts` — mount map for `mounts` mode
+- `sandboxEnabled`, `sandbox`, `localSandboxOptions`
+- `onMount` — hook before mounting cloud filesystems into a sandbox
+
+Adapter hooks available on the HTTP layer:
+
+- `contextResolver(request)` — derive tenancy and ownership from auth/session headers
+- `authorize({ action, request, context })` — gate create/read/write/resume operations
+- `allowClientResourceId` — only enable for local development or trusted callers
+
+NestJS standalone server:
+
+```typescript
+import { createStandaloneHarnessNestServer } from '@lumifai/harness-server-nest';
+
+await createStandaloneHarnessNestServer({
+  port: 4310,
+  bootConfig: { workspaceMode: 'local', sandboxEnabled: true },
+});
+```
+
+## Tool permissions
+
+The server applies preset permission defaults automatically via `buildHarnessOptions()`:
+
+- **Read** tools (workspace reads, schema inspection) → auto-approved
+- **Edit / execute / other** categories → prompt for approval (`ask`)
+- **Tool pack defaults** → per-tool overrides from each pack's `toolConfig`
+- `request_access` is only enabled when the workspace exposes a local filesystem, because that path is persisted via local filesystem state.
+
+Override from server boot (recommended):
+
+```typescript
+import { createHarnessSessionManager } from '@lumifai/harness-server';
+import { createPostgresToolPack } from '@lumifai/harness-tool-pack-postgres';
+
+createHarnessSessionManager({
+  bootConfig: {
+    toolPacks: [createPostgresToolPack({ connectionString: process.env.DATABASE_URL! })],
+    permissionRules: {
+      tools: { my_custom_tool: 'ask' },
+      categories: { execute: 'deny' },
+    },
+  },
+});
+```
+
+Direct harness construction:
+
+```typescript
+import { createPresetPermissionConfig } from '@lumifai/harness-presets';
+
+createLumifHarness({
+  ...createPresetPermissionConfig({
+    packs: [
+      /* tool packs */
+    ],
+    overrides: { tools: { my_custom_tool: 'ask' } },
+  }),
+  // workspace, modes, tools, ...
+});
+```
+
+Custom tools:
+
+- Add via `bootConfig.extraTools` (Fastify/Nest) or `createPresetTools({ extra: { my_tool: createTool({...}) } })`
+- Set deployment policy in `bootConfig.permissionRules.tools.my_tool`
+- Use `requireApproval` on `createTool` only when approval is intrinsic to the tool design
+- Optional: wrap reusable custom tools in a local `ToolPack` with `toolConfig` / `permissionPolicies`
+- For durable HITL, give the tool `suspendSchema` / `resumeSchema` and call `suspend()`; pair with a
+  client `defineSuspensionRenderer` (see Browser UI)
+
+Permissions are server-owned and are not exposed on the session `HarnessConfigPatch` API.
+
+## Browser UI
+
+- `@lumifai/harness-client` — framework-agnostic browser client and shared reducer/state helpers
+- `@lumifai/harness-react` — headless provider, hooks, browser client, session store, suspension renderer registry
+- `@lumifai/harness-react-mantine` — Mantine `HarnessStudio` components
+
+The browser client refreshes its authoritative session snapshot after an SSE failure,
+and the serialized display state retains the latest run error as `lastError`. The
+Mantine studio renders concurrent pending suspensions and supports free-text,
+single-select, and multi-select `ask_user` responses.
+
+Custom suspension UIs: pass `suspensionRenderers` to `HarnessProvider` and/or `HarnessStudio`.
+Studio merges builtins (`ask_user`, `submit_plan`, `request_access`) then provider then studio
+props (later wins by `toolName`). Headless apps can call `useResolvedSuspensionRenderer(suspension)`
+and `resumeToolSuspension(data, toolCallId)`.
+
+## Presets
+
+Import configurable presets from `@lumifai/harness-presets`:
+
+- `createPresetModes()` — `plan` and `build` modes
+- `createPresetCustomModes()` — returns the built-in modes plus your custom list when you need the final array yourself
+- `createPresetSubagents()` — `explore` subagent; opt-in `websearch` subagent via `includeWebSearch: true`
+- `createPresetTools()` — Lumif baseline with `ask_user` and `submit_plan` (displaces Mastra builtins). Pass `packs`, `toolPackToggles`, `toolToggles`, `includeRequestAccess`, and/or `extra`
+- `createPresetSkills()` — default `.agents/skills` resolver paths
+- `createPresetHarnessConfig()` — combines the above and merges enabled pack skill paths
+- `createPresetPermissionConfig()` — default category resolver and merged `permissionRules` for harness init
+
+## Tool packs
+
+Import opt-in capability bundles from `@lumifai/harness-tool-pack-*` packages. Shared types and merge helpers live in `@lumifai/harness-tool-packs`:
+
+- `ToolPack` — named bundle of related tools (and optional skills) that flattens into `tools` at harness init
+- `createPostgresToolPack()` — read-only PostgreSQL schema inspection and query tools (`@lumifai/harness-tool-pack-postgres`)
+- `createWorkspaceDataToolPack()` — workspace JSON, CSV, and jq query tools (`@lumifai/harness-tool-pack-workspace-data`)
+- `createServerlessWorkflowToolPack()` — serverless runtime tool pack (`@lumifai/harness-tool-pack-serverless-workflow`)
+- `createWebSearchToolPack()` — provider-native web search with structured output (`@lumifai/harness-tool-pack-web-search`)
+- `createFileProcessingToolPack()` — PDF text extraction to `/processed/` (`@lumifai/harness-tool-pack-file-processing`)
+
+Override any preset or pack via the options objects on each factory.
+
+Example:
+
+```ts
+import { createPresetHarnessConfig } from '@lumifai/harness-presets';
+import { createPostgresToolPack } from '@lumifai/harness-tool-pack-postgres';
+import { createServerlessWorkflowToolPack } from '@lumifai/harness-tool-pack-serverless-workflow';
+import { createWebSearchToolPack } from '@lumifai/harness-tool-pack-web-search';
+import { createFileProcessingToolPack } from '@lumifai/harness-tool-pack-file-processing';
+import { createWorkspaceDataToolPack } from '@lumifai/harness-tool-pack-workspace-data';
+import { Agent } from '@mastra/core/agent';
+
+const presets = createPresetHarnessConfig({
+  subagents: {
+    includeWebSearch: true,
+    webSearchProvider: 'openai',
+  },
+  customModes: [
+    {
+      id: 'review',
+      name: 'Review',
+      defaultModelId: 'openai/gpt-5.4-mini',
+      color: '#059669',
+      agent: new Agent({
+        id: 'lumif-review-agent',
+        name: 'Review Agent',
+        instructions: 'Review the user changes and report issues.',
+        model: 'openai/gpt-5.4-mini',
+      }),
+    },
+  ],
+  skills: {
+    paths: ['.agents/skills'],
+  },
+  tools: {
+    packs: [
+      createWorkspaceDataToolPack(),
+      createPostgresToolPack({
+        connectionString: process.env.DATABASE_URL,
+        allowAllRoleVisible: true,
+        // or resolveAccessPolicy / resolveConnectionString for production tenants
+      }),
+      createServerlessWorkflowToolPack({
+        runtimeHost: process.env.RUNTIME_HOST!,
+        workflowNamespace: 'lumif',
+        resolveAuthContext: (ctx) => ({
+          accessToken: ctx.requestContext?.auth?.accessToken ?? '',
+        }),
+      }),
+      createWebSearchToolPack({
+        defaultProvider: 'openai',
+      }),
+      createFileProcessingToolPack(),
+    ],
+    toolPackToggles: {
+      postgres: true,
+    },
+    toolToggles: {
+      postgres_query: true,
+    },
+  },
+});
+```
+
+### Tool pack toggles
+
+- `toolPackToggles` — enable or disable an entire pack (tools and bundled skills)
+- `toolToggles` — enable or disable individual tools by id within enabled packs
+- `toolConfig.enabledByDefault` on a pack — default per-tool state before `toolToggles` overrides
+
+Tool packs are published as separate `@lumifai/harness-tool-pack-*` packages. Their bundled skills are merged into `workspace.skills` automatically when the pack is enabled.

package/dist/create-lumif-harness.d.ts

@@ -0,0 +1,3 @@
+import { AgentController } from '@mastra/core/agent-controller';
+import type { LumifHarnessOptions } from './types';
+export declare function createLumifHarness<TState = {}>(options: LumifHarnessOptions<TState>): AgentController<TState>;

package/dist/create-lumif-harness.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLumifHarness = createLumifHarness;
+const agent_controller_1 = require("@mastra/core/agent-controller");
+const workspace_1 = require("@mastra/core/workspace");
+function assertWorkspace(workspace) {
+    if (workspace === undefined || workspace === null) {
+        throw new Error('LumifHarness requires a workspace. Pass a Workspace instance, WorkspaceConfig, or a factory function.');
+    }
+}
+function createLumifHarness(options) {
+    assertWorkspace(options.workspace);
+    const workspace = normalizeWorkspace(options.workspace);
+    const { heartbeatHandlers, intervalHandlers, ...config } = options;
+    if (heartbeatHandlers && intervalHandlers) {
+        throw new Error('Pass either heartbeatHandlers or intervalHandlers, not both.');
+    }
+    return new agent_controller_1.AgentController({
+        ...config,
+        workspace,
+        intervalHandlers: intervalHandlers ?? heartbeatHandlers,
+    });
+}
+function isPromiseLike(value) {
+    return value != null && typeof value.then === 'function';
+}
+function normalizeWorkspace(workspace) {
+    if (typeof workspace === 'function') {
+        const factory = workspace;
+        return (input) => {
+            const resolved = factory(input);
+            if (isPromiseLike(resolved)) {
+                return Promise.resolve(resolved).then((value) => value ? normalizeWorkspaceValue(value) : undefined);
+            }
+            return resolved ? normalizeWorkspaceValue(resolved) : undefined;
+        };
+    }
+    return normalizeWorkspaceValue(workspace);
+}
+function normalizeWorkspaceValue(workspace) {
+    return workspace instanceof workspace_1.Workspace
+        ? workspace
+        : new workspace_1.Workspace(workspace);
+}
+//# sourceMappingURL=create-lumif-harness.js.map

package/dist/create-lumif-harness.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-lumif-harness.js","sourceRoot":"","sources":["../src/create-lumif-harness.ts"],"names":[],"mappings":";;AAoBA,gDAiBC;AArCD,oEAA4F;AAE5F,sDAAyE;AAQzE,SAAS,eAAe,CACtB,SAA2C;IAE3C,IAAI,SAAS,KAAK,SAAS,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;QAClD,MAAM,IAAI,KAAK,CACb,uGAAuG,CACxG,CAAC;IACJ,CAAC;AACH,CAAC;AAED,SAAgB,kBAAkB,CAChC,OAAoC;IAEpC,eAAe,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAEnC,MAAM,SAAS,GAAG,kBAAkB,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IACxD,MAAM,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,GAAG,MAAM,EAAE,GAAG,OAAO,CAAC;IAEnE,IAAI,iBAAiB,IAAI,gBAAgB,EAAE,CAAC;QAC1C,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;IAClF,CAAC;IAED,OAAO,IAAI,kCAAe,CAAC;QACzB,GAAG,MAAM;QACT,SAAS;QACT,gBAAgB,EAAE,gBAAgB,IAAI,iBAAiB;KACvB,CAAC,CAAC;AACtC,CAAC;AAED,SAAS,aAAa,CAAI,KAAyB;IACjD,OAAO,KAAK,IAAI,IAAI,IAAI,OAAQ,KAAwB,CAAC,IAAI,KAAK,UAAU,CAAC;AAC/E,CAAC;AAED,SAAS,kBAAkB,CACzB,SAA+D;IAE/D,IAAI,OAAO,SAAS,KAAK,UAAU,EAAE,CAAC;QACpC,MAAM,OAAO,GAAG,SAAS,CAAC;QAC1B,OAAO,CAAC,KAAK,EAAE,EAAE;YACf,MAAM,QAAQ,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;YAChC,IAAI,aAAa,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC5B,OAAO,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC9C,KAAK,CAAC,CAAC,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CACnD,CAAC;YACJ,CAAC;YACD,OAAO,QAAQ,CAAC,CAAC,CAAC,uBAAuB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAClE,CAAC,CAAC;IACJ,CAAC;IAED,OAAO,uBAAuB,CAAC,SAAS,CAAC,CAAC;AAC5C,CAAC;AAED,SAAS,uBAAuB,CAC9B,SAAuF;IAEvF,OAAO,SAAS,YAAY,qBAAS;QACnC,CAAC,CAAE,SAAuB;QAC1B,CAAC,CAAC,IAAI,qBAAS,CAAC,SAA4B,CAAC,CAAC;AAClD,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { createLumifHarness } from './create-lumif-harness';
+export type { LumifHarnessOptions, LumifWorkspace, LumifWorkspaceFactory } from './types';
+export { AgentController, Session } from '@mastra/core/agent-controller';
+/** Lumif's stable Harness export, backed by Mastra's AgentController runtime. */
+export { AgentController as Harness } from '@mastra/core/agent-controller';
+export type { AgentControllerConfig, AgentControllerDisplayState, AgentControllerEvent, AgentControllerMode, AgentControllerSubagent, AgentControllerThread, AgentControllerConfig as HarnessConfig, AgentControllerDisplayState as HarnessDisplayState, AgentControllerEvent as HarnessEvent, AgentControllerMode as HarnessMode, AgentControllerSubagent as HarnessSubagent, AgentControllerThread as HarnessThread, } from '@mastra/core/agent-controller';

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Harness = exports.Session = exports.AgentController = exports.createLumifHarness = void 0;
+var create_lumif_harness_1 = require("./create-lumif-harness");
+Object.defineProperty(exports, "createLumifHarness", { enumerable: true, get: function () { return create_lumif_harness_1.createLumifHarness; } });
+var agent_controller_1 = require("@mastra/core/agent-controller");
+Object.defineProperty(exports, "AgentController", { enumerable: true, get: function () { return agent_controller_1.AgentController; } });
+Object.defineProperty(exports, "Session", { enumerable: true, get: function () { return agent_controller_1.Session; } });
+/** Lumif's stable Harness export, backed by Mastra's AgentController runtime. */
+var agent_controller_2 = require("@mastra/core/agent-controller");
+Object.defineProperty(exports, "Harness", { enumerable: true, get: function () { return agent_controller_2.AgentController; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,+DAA4D;AAAnD,0HAAA,kBAAkB,OAAA;AAG3B,kEAAyE;AAAhE,mHAAA,eAAe,OAAA;AAAE,2GAAA,OAAO,OAAA;AACjC,iFAAiF;AACjF,kEAA2E;AAAlE,2GAAA,eAAe,OAAW"}

package/dist/types.d.ts

@@ -0,0 +1,18 @@
+import type { AgentControllerConfig } from '@mastra/core/agent-controller';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { Mastra } from '@mastra/core';
+import type { Workspace, WorkspaceConfig, WorkspaceFilesystem, WorkspaceSandbox } from '@mastra/core/workspace';
+type MountCapableWorkspaceConfig = WorkspaceConfig<WorkspaceFilesystem | undefined, WorkspaceSandbox | undefined, Record<string, WorkspaceFilesystem> | undefined>;
+type MountCapableWorkspace = Workspace<WorkspaceFilesystem | undefined, WorkspaceSandbox | undefined, Record<string, WorkspaceFilesystem> | undefined>;
+export type LumifWorkspaceFactory = (input: {
+    requestContext: RequestContext;
+    mastra?: Mastra;
+}) => Workspace | MountCapableWorkspace | MountCapableWorkspaceConfig | undefined | Promise<Workspace | MountCapableWorkspace | MountCapableWorkspaceConfig | undefined>;
+export type LumifWorkspace<_TState = {}> = Workspace | MountCapableWorkspace | MountCapableWorkspaceConfig | LumifWorkspaceFactory;
+export type LumifHarnessOptions<TState = {}> = Omit<AgentControllerConfig<TState>, 'workspace' | 'intervalHandlers'> & {
+    workspace: LumifWorkspace<TState>;
+    /** @deprecated Renamed to `intervalHandlers` by Mastra. */
+    heartbeatHandlers?: AgentControllerConfig<TState>['intervalHandlers'];
+    intervalHandlers?: AgentControllerConfig<TState>['intervalHandlers'];
+};
+export {};

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@lumifai/harness",
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "README.md"
+  ],
+  "dependencies": {
+    "@mastra/core": "1.50.1"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
+}