@h-rig/contracts 0.0.6-alpha.18 → 0.0.6-alpha.181

package/dist/src/provider-instructions.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure provider-instruction contract types.
+ *
+ * Neutral home for the agent-harness provider identity so the dumb runtime
+ * substrate (native/task-ops, hooks/inject-context) and the
+ * @rig/provider-plugin that owns the instruction text can both reference it
+ * without a substrate->plugin import cycle. Carries no behaviour and imports
+ * nothing — exactly like `memory.ts` / `lifecycle-capabilities.ts`.
+ *
+ * The plugin registers its executable `RuntimeInstructionService` impl under the
+ * typed id {@link RUNTIME_INSTRUCTION} (whose string value is
+ * {@link RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID}) via `*.provide`; the runtime
+ * resolves it by id from `pluginHost.listExecutableCapabilities()` via the
+ * `defineCapability` seam (`@rig/core/capability`), re-exported from the thin
+ * `@rig/runtime/control-plane/provider-instruction-port`.
+ */
+import type { CapabilityId } from "./capability-id";
+/** Capability id the provider plugin registers its instruction service under. */
+export declare const RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+/** The agent harness adapter the runtime is currently wired to. */
+export type RuntimeInstructionProvider = "pi";
+/**
+ * The cohesive set of agent-harness instruction builders the runtime consumers
+ * depend on. This is pure capability VOCAB: the `@rig/provider-plugin` provides a
+ * concrete impl (statically checked against this interface via the typed
+ * capability seam), and the substrate only ever sees this contract — resolved by
+ * id off a plugin host with no `as unknown as` at any call site.
+ */
+export interface RuntimeInstructionService {
+    normalizeProvider(value: string | undefined | null): RuntimeInstructionProvider;
+    buildTaskRunInstructionLines(provider: RuntimeInstructionProvider): string[];
+    buildRuntimeContextLines(provider: RuntimeInstructionProvider): string[];
+}
+/**
+ * The typed capability id the provider plugin provides and consumers require.
+ * Phantom-typed with `RuntimeInstructionService` so `resolve(host)` returns a
+ * `RuntimeInstructionService` with no cast leaking to callers. Its string value
+ * is {@link RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID}, so it indexes the same
+ * host entry.
+ */
+export declare const RUNTIME_INSTRUCTION: CapabilityId<RuntimeInstructionService>;

package/dist/src/provider-instructions.js

@@ -0,0 +1,13 @@
+// @bun
+// packages/contracts/src/capability-id.ts
+function makeCapabilityId(id) {
+  return id;
+}
+
+// packages/contracts/src/provider-instructions.ts
+var RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID = "provider.runtime-instructions";
+var RUNTIME_INSTRUCTION = makeCapabilityId(RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID);
+export {
+  RUNTIME_INSTRUCTION_SERVICE_CAPABILITY_ID,
+  RUNTIME_INSTRUCTION
+};

package/dist/src/provider.d.ts

@@ -0,0 +1,105 @@
+import { Schema } from "effect";
+import type { CapabilityId } from "./capability-id";
+export declare const ProviderSession: Schema.Struct<{
+    readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+    readonly status: Schema.Literals<readonly ["connecting", "ready", "running", "error", "closed"]>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+    readonly cwd: Schema.optional<Schema.Trim>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly resumeCursor: Schema.optional<Schema.Unknown>;
+    readonly activeTurnId: Schema.optional<Schema.brand<Schema.Trim, "TurnId">>;
+    readonly createdAt: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly lastError: Schema.optional<Schema.Trim>;
+}>;
+export type ProviderSession = typeof ProviderSession.Type;
+export declare const ProviderSessionStartInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly provider: Schema.optional<Schema.Literals<readonly ["codex", "claude"]>>;
+    readonly cwd: Schema.optional<Schema.Trim>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly modelOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly resumeCursor: Schema.optional<Schema.Unknown>;
+    readonly serviceTier: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["fast", "flex"]>>>;
+    readonly approvalPolicy: Schema.optional<Schema.Literals<readonly ["untrusted", "on-failure", "on-request", "never"]>>;
+    readonly sandboxMode: Schema.optional<Schema.Literals<readonly ["read-only", "workspace-write", "danger-full-access"]>>;
+    readonly providerOptions: Schema.optional<Schema.Struct<{
+        readonly codex: Schema.optional<Schema.Struct<{
+            readonly binaryPath: Schema.optional<Schema.Trim>;
+            readonly homePath: Schema.optional<Schema.Trim>;
+        }>>;
+    }>>;
+    readonly runtimeMode: Schema.Literals<readonly ["approval-required", "full-access"]>;
+}>;
+export type ProviderSessionStartInput = typeof ProviderSessionStartInput.Type;
+export declare const ProviderSendTurnInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly input: Schema.optional<Schema.Trim>;
+    readonly attachments: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"image">;
+        readonly id: Schema.Trim;
+        readonly name: Schema.Trim;
+        readonly mimeType: Schema.Trim;
+        readonly sizeBytes: Schema.Int;
+    }>]>>>;
+    readonly model: Schema.optional<Schema.Trim>;
+    readonly serviceTier: Schema.optional<Schema.NullOr<Schema.Literals<readonly ["fast", "flex"]>>>;
+    readonly modelOptions: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+    readonly interactionMode: Schema.optional<Schema.Literals<readonly ["default", "plan"]>>;
+}>;
+export type ProviderSendTurnInput = typeof ProviderSendTurnInput.Type;
+export declare const ProviderTurnStartResult: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly turnId: Schema.brand<Schema.Trim, "TurnId">;
+    readonly resumeCursor: Schema.optional<Schema.Unknown>;
+}>;
+export type ProviderTurnStartResult = typeof ProviderTurnStartResult.Type;
+export declare const ProviderInterruptTurnInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly turnId: Schema.optional<Schema.brand<Schema.Trim, "TurnId">>;
+}>;
+export type ProviderInterruptTurnInput = typeof ProviderInterruptTurnInput.Type;
+export declare const ProviderStopSessionInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+}>;
+export type ProviderStopSessionInput = typeof ProviderStopSessionInput.Type;
+export declare const ProviderRespondToRequestInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly decision: Schema.Literals<readonly ["accept", "acceptForSession", "decline", "cancel"]>;
+}>;
+export type ProviderRespondToRequestInput = typeof ProviderRespondToRequestInput.Type;
+export declare const ProviderRespondToUserInputInput: Schema.Struct<{
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly requestId: Schema.brand<Schema.Trim, "ApprovalRequestId">;
+    readonly answers: Schema.$Record<Schema.String, Schema.Unknown>;
+}>;
+export type ProviderRespondToUserInputInput = typeof ProviderRespondToUserInputInput.Type;
+export declare const ProviderEvent: Schema.Struct<{
+    readonly id: Schema.brand<Schema.Trim, "EventId">;
+    readonly kind: Schema.Literals<readonly ["session", "notification", "request", "error"]>;
+    readonly provider: Schema.Literals<readonly ["codex", "claude"]>;
+    readonly threadId: Schema.brand<Schema.Trim, "ThreadId">;
+    readonly createdAt: Schema.String;
+    readonly method: Schema.Trim;
+    readonly message: Schema.optional<Schema.Trim>;
+    readonly turnId: Schema.optional<Schema.brand<Schema.Trim, "TurnId">>;
+    readonly itemId: Schema.optional<Schema.brand<Schema.Trim, "ProviderItemId">>;
+    readonly requestId: Schema.optional<Schema.brand<Schema.Trim, "ApprovalRequestId">>;
+    readonly requestKind: Schema.optional<Schema.Literals<readonly ["command", "file-read", "file-change"]>>;
+    readonly textDelta: Schema.optional<Schema.String>;
+    readonly payload: Schema.optional<Schema.Unknown>;
+}>;
+export type ProviderEvent = typeof ProviderEvent.Type;
+export interface AgentHarnessRunWrapperInput {
+    readonly argv: readonly string[];
+}
+export interface AgentHarnessService {
+    /** Provider-owned source entrypoint used when a project-local rig-agent binary must be materialized from source. */
+    readonly resolveAgentWrapperEntrypoint: () => string;
+    readonly runAgentWrapper: (input: AgentHarnessRunWrapperInput) => Promise<number>;
+    readonly runRigAgentEntrypoint: () => Promise<void>;
+}
+export declare const AGENT_HARNESS_CAPABILITY_ID = "rig.provider.agent-harness";
+export declare const AGENT_HARNESS: CapabilityId<AgentHarnessService>;