@opencode/core 0.0.0-reserved → 2.0.1

package/dist/chunks/repository-xjmr3883.js

@@ -0,0 +1,118 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  ID16
+} from "./repository-pye8sh6e.js";
+import {
+  iife2
+} from "./repository-1kg9ymc8.js";
+import {
+  configuredSettings2
+} from "./repository-5b88mxz1.js";
+
+// src/plugin/provider/cloudflare-ai-gateway.ts
+import os from "os";
+import { Effect, Option, Schema } from "effect";
+import { define } from "@opencode/plugin/effect/plugin";
+import { Form } from "@opencode/schema/form";
+var providerID = ID16.make("cloudflare-ai-gateway");
+var CloudflareAIGatewayPlugin2 = define({
+  id: "opencode.provider.cloudflare.ai.gateway",
+  effect: Effect.fn(function* (ctx) {
+    const configured = yield* configuredSettings2(providerID);
+    const form = iife2(() => {
+      if (typeof configured?.baseURL === "string")
+        return;
+      const accountId = process.env.CLOUDFLARE_ACCOUNT_ID || stringOption(configured ?? {}, "accountId");
+      const gatewayId = process.env.CLOUDFLARE_GATEWAY_ID || stringOption(configured ?? {}, "gatewayId") || stringOption(configured ?? {}, "gateway");
+      if (accountId && gatewayId)
+        return;
+      const accountIdForm = Form.StringField.make({
+        type: "string",
+        key: "accountId",
+        title: "Enter your Cloudflare Account ID",
+        placeholder: "e.g. 1234567890abcdef1234567890abcdef",
+        required: true
+      });
+      const gatewayIdForm = Form.StringField.make({
+        type: "string",
+        key: "gatewayId",
+        title: "Enter your Cloudflare AI Gateway ID",
+        placeholder: "e.g. my-gateway",
+        required: true
+      });
+      if (accountId)
+        return Form.Fields.make([gatewayIdForm]);
+      if (gatewayId)
+        return Form.Fields.make([accountIdForm]);
+      return Form.Fields.make([accountIdForm, gatewayIdForm]);
+    });
+    yield* ctx.integration.transform((editor) => {
+      editor.method.update({
+        integrationID: providerID,
+        method: {
+          type: "key",
+          label: "Gateway API token",
+          form
+        }
+      });
+    });
+    yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
+      if (evt.package !== "ai-gateway-provider")
+        return;
+      if (evt.options.baseURL)
+        return;
+      const config = gatewayConfig(evt.options);
+      if (!config)
+        return;
+      const metadata = gatewayMetadata(evt.options);
+      const { createAiGateway } = yield* Effect.promise(() => import("ai-gateway-provider"));
+      const { createUnified } = yield* Effect.promise(() => import("ai-gateway-provider/providers/unified"));
+      const gateway = createAiGateway({
+        accountId: config.accountId,
+        gateway: config.gatewayId,
+        apiKey: config.apiKey,
+        options: gatewayOptions(evt.options, metadata, ctx.app)
+      });
+      const unified = createUnified({ apiKey: config.apiKey });
+      evt.sdk = {
+        languageModel(modelID) {
+          return gateway(unified(modelID));
+        }
+      };
+    }));
+  })
+});
+var decodeJson = Schema.decodeUnknownOption(Schema.fromJsonString(Schema.Unknown));
+function gatewayConfig(options) {
+  const accountId = process.env.CLOUDFLARE_ACCOUNT_ID ?? stringOption(options, "accountId");
+  const gatewayId = process.env.CLOUDFLARE_GATEWAY_ID ?? stringOption(options, "gatewayId") ?? stringOption(options, "gateway");
+  const apiKey = process.env.CLOUDFLARE_API_TOKEN ?? process.env.CF_AIG_TOKEN ?? stringOption(options, "apiKey");
+  if (!accountId || !gatewayId || !apiKey)
+    return;
+  return { accountId, gatewayId, apiKey };
+}
+function gatewayMetadata(options) {
+  if (options.metadata !== undefined)
+    return options.metadata;
+  const raw = options.headers?.["cf-aig-metadata"];
+  return raw ? Option.getOrUndefined(decodeJson(raw)) : undefined;
+}
+function gatewayOptions(options, metadata, app) {
+  return {
+    metadata,
+    cacheTtl: options.cacheTtl,
+    cacheKey: options.cacheKey,
+    skipCache: options.skipCache,
+    collectLog: options.collectLog,
+    headers: {
+      "User-Agent": `${useragent2(app)} cloudflare-ai-gateway (${os.platform()} ${os.release()}; ${os.arch()})`
+    }
+  };
+}
+function stringOption(options, key) {
+  return typeof options[key] === "string" ? options[key] : undefined;
+}
+
+export { CloudflareAIGatewayPlugin2 };

package/dist/chunks/repository-xp6wb0v9.js

@@ -0,0 +1,170 @@
+import {
+  Service78,
+  node83
+} from "./repository-x6rcf4cj.js";
+import {
+  Service66,
+  node70
+} from "./repository-6wjjjhy6.js";
+import {
+  reconcile2,
+  create3
+} from "./repository-kg06axw8.js";
+import {
+  PATCH_CONTEXT_LINES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2
+} from "./repository-tazgh4e4.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/vcs.ts
+var exports_vcs = {};
+__export(exports_vcs, {
+  Base: () => Base2,
+  BranchList: () => BranchList2,
+  DiffError: () => DiffError2,
+  FileStatus: () => FileStatus2,
+  Info: () => Info3,
+  Mode: () => Mode2,
+  Service: () => Service17,
+  Vcs: () => exports_vcs,
+  node: () => node21
+});
+import path from "path";
+import { Cause, Context, Effect, FiberSet, Layer, Schema, Semaphore, Stream } from "effect";
+import { FileDiff } from "@opencode/schema/file-diff";
+import { FileSystem } from "@opencode/schema/filesystem";
+import { Base as Base2, BranchList as BranchList2, FileStatus as FileStatus2, Info as Info3, Mode as Mode2 } from "@opencode/schema/vcs";
+import { VcsEvent } from "@opencode/schema/vcs-event";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+class DiffError2 extends Schema.TaggedError()("Vcs.DiffError", {
+  message: Schema.String
+}) {
+}
+
+class Service17 extends Context.Service()("@opencode/Vcs") {
+}
+var layer = Layer.effect(Service17, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const location = yield* Service66;
+  const bus = yield* Service78;
+  const root = yield* Effect.scope;
+  const fork = yield* FiberSet.makeRuntime();
+  const vcs = location.vcs;
+  const current = { info: { branch: {} } };
+  const refreshLock = Semaphore.makeUnsafe(1);
+  const scope = {
+    directory: location.directory,
+    worktree: location.project.directory,
+    canonical: location.project.canonical,
+    ...vcs ? { store: vcs.store } : {}
+  };
+  const decodeInfo = Schema.decodeUnknownEffect(Schema.toType(Info3));
+  const decodeBase = Schema.decodeUnknownEffect(Schema.NullOr(Base2));
+  const decodeBranches = Schema.decodeUnknownEffect(BranchList2);
+  const decodeStatus = Schema.decodeUnknownEffect(Schema.Array(FileStatus2));
+  const decodeDiff = Schema.decodeUnknownEffect(Schema.Array(FileDiff.Info));
+  const state = create3({
+    name: "vcs",
+    initial: () => ({ providers: new Map }),
+    editor: (editor) => ({
+      add: (provider) => editor.providers.set(provider.id, provider),
+      default: {
+        get: () => editor.selection,
+        set: (selection) => editor.selection = selection
+      }
+    }),
+    notify: () => reconcile2(root, fork, () => refresh())
+  });
+  const selected = () => {
+    const value = state.get();
+    const id = value.selection ?? vcs?.type;
+    return id ? value.providers.get(id) : undefined;
+  };
+  const protect = (provider, operation, effect, fallback) => effect.pipe(Effect.catchCause((cause) => Cause.hasInterrupts(cause) ? Effect.failCause(cause).pipe(Effect.orDie) : Effect.logWarning("vcs provider failed", { provider: provider.id, operation, cause }).pipe(Effect.as(fallback))));
+  const review = (provider, operation, effect) => effect.pipe(Effect.catchCause((cause) => {
+    if (Cause.hasInterrupts(cause))
+      return Effect.failCause(cause).pipe(Effect.orDie);
+    const error = Cause.squash(cause);
+    return Effect.logWarning("vcs provider failed", { provider: provider.id, operation, cause }).pipe(Effect.andThen(Effect.fail(error instanceof DiffError2 ? error : new DiffError2({
+      message: operation === "base" ? "VCS provider could not resolve a review base" : "VCS provider could not produce a diff"
+    }))));
+  }));
+  const refresh = Effect.fn("Vcs.refresh")(function* () {
+    const changed = yield* Effect.gen(function* () {
+      const provider = selected();
+      const next = provider ? yield* protect(provider, "info", provider.info(scope).pipe(Effect.flatMap(decodeInfo)), { branch: {} }) : { branch: {} };
+      const changed = current.info.branch.current !== next.branch.current;
+      current.info = next;
+      return changed;
+    }).pipe(Semaphore.withPermit(refreshLock));
+    if (!changed)
+      return;
+    while (true) {
+      const branch = current.info.branch.current;
+      yield* bus.publish(VcsEvent.BranchUpdated, { branch });
+      if (branch === current.info.branch.current)
+        return;
+    }
+  });
+  if (vcs) {
+    const store = yield* fs.realPath(vcs.store).pipe(Effect.orElseSucceed(() => vcs.store));
+    const isBranchMetadata = vcs.type === "git" ? (file) => path.basename(file) === "HEAD" && FSUtil.contains(store, file) : (file) => path.resolve(file) === path.join(store, "branch");
+    yield* bus.subscribe(FileSystem.Event.Changed).pipe(Stream.filter((event) => isBranchMetadata(event.data.file)), Stream.runForEach((event) => refresh().pipe(Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => Effect.logWarning("vcs refresh failed", { file: event.data.file, cause })), Effect.withSpan("Vcs.refreshBranch", { attributes: { file: event.data.file } }))), Effect.forkScoped({ startImmediately: true }));
+  }
+  return Service17.of({
+    transform: state.transform,
+    reload: state.reload,
+    info: Effect.fn("Vcs.info")(function* () {
+      return current.info;
+    }),
+    base: Effect.fn("Vcs.base")(function* () {
+      const provider = selected();
+      if (!provider?.base)
+        return null;
+      return yield* review(provider, "base", provider.base(scope).pipe(Effect.flatMap(decodeBase)));
+    }),
+    branches: Effect.fn("Vcs.branches")(function* (options) {
+      const provider = selected();
+      if (provider)
+        return yield* protect(provider, "branches", provider.branches({ ...scope, ...options }).pipe(Effect.flatMap(decodeBranches)), []);
+      return [];
+    }),
+    status: Effect.fn("Vcs.status")(function* () {
+      const provider = selected();
+      if (provider)
+        return yield* protect(provider, "status", provider.status(scope).pipe(Effect.flatMap(decodeStatus), Effect.map((rows) => Array.from(rows))), []);
+      return [];
+    }),
+    diff: Effect.fn("Vcs.diff")(function* (mode, options) {
+      const provider = selected();
+      if (!provider)
+        return [];
+      const rows = yield* review(provider, "diff", provider.diff({
+        ...scope,
+        mode,
+        ...options?.base !== undefined ? { base: options.base } : {},
+        context: options?.context ?? PATCH_CONTEXT_LINES2,
+        maxOutputBytes: MAX_TOTAL_PATCH_BYTES2
+      }).pipe(Effect.flatMap(decodeDiff)));
+      let total = 0;
+      return rows.map((row) => {
+        const bytes = Buffer.byteLength(row.patch);
+        if (total + bytes > MAX_TOTAL_PATCH_BYTES2)
+          return { ...row, patch: emptyPatch2(row.file) };
+        total += bytes;
+        return row;
+      });
+    })
+  });
+}));
+var node21 = makeLocationNode({
+  service: Service17,
+  layer,
+  deps: [FSUtil.node, node70, node83]
+});
+
+export { Base2, BranchList2, FileStatus2, Info3, Mode2, DiffError2, Service17, node21, exports_vcs };

package/dist/chunks/repository-xqzn0vp7.js

@@ -0,0 +1,191 @@
+import {
+  Service66
+} from "./repository-6wjjjhy6.js";
+import {
+  PATCH_CONTEXT_LINES2,
+  MAX_PATCH_BYTES2,
+  MAX_TOTAL_PATCH_BYTES2,
+  emptyPatch2,
+  addPatch2,
+  deletePatch2,
+  countPatch2,
+  chunksByFile2
+} from "./repository-tazgh4e4.js";
+import {
+  DiffError2
+} from "./repository-xp6wb0v9.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/vcs/hg.ts
+var exports_hg = {};
+__export(exports_hg, {
+  Plugin: () => Plugin36,
+  VcsHgPlugin: () => exports_hg
+});
+import path from "path";
+import { Effect } from "effect";
+import { ChildProcess } from "effect/unstable/process";
+import { define } from "@opencode/plugin/effect/plugin";
+import { FSUtil } from "@opencode/util/fs-util";
+import { AppProcess } from "@opencode/util/process";
+var Plugin36 = define({
+  id: "opencode.vcs.hg",
+  effect: Effect.fn("VcsHgPlugin")(function* (ctx) {
+    const location = yield* Service66;
+    if (location.vcs?.type !== "hg")
+      return;
+    const processes = yield* AppProcess.Service;
+    const fs = yield* FSUtil.Service;
+    const adapter = make(processes, fs, {
+      directory: location.directory,
+      worktree: location.project.directory
+    });
+    yield* ctx.vcs.transform((editor) => {
+      editor.add({
+        id: "hg",
+        name: "Mercurial",
+        info: () => adapter.info(),
+        branches: (input) => adapter.branches({ search: input.search, limit: input.limit }),
+        status: () => adapter.status(),
+        diff: (input) => adapter.diff(input.mode, { context: input.context, base: input.base })
+      });
+    });
+  })
+});
+function make(proc, fs, input) {
+  const hg = makeHg(proc, input.worktree);
+  const scope = path.relative(input.worktree, input.directory) || ".";
+  const patchFor = Effect.fnUntraced(function* (item, rev, chunk) {
+    if (chunk !== undefined)
+      return chunk;
+    if (item.code === "?") {
+      const content = yield* fs.readFileString(path.join(input.worktree, item.file)).pipe(Effect.orElseSucceed(() => {
+        return;
+      }));
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES2)
+        return emptyPatch2(item.file);
+      return addPatch2(item.file, content);
+    }
+    if (item.code === "!") {
+      const content = yield* hg.cat(rev ?? ".", item.file);
+      if (content === undefined || Buffer.byteLength(content) > MAX_PATCH_BYTES2)
+        return emptyPatch2(item.file);
+      return deletePatch2(item.file, content);
+    }
+    return emptyPatch2(item.file);
+  });
+  const diffAgainst = Effect.fnUntraced(function* (rev, options) {
+    const [items, batch] = yield* Effect.all([hg.status(rev, scope), hg.diff(rev, scope, { context: options?.context ?? PATCH_CONTEXT_LINES2 })], { concurrency: 2 });
+    const chunks = chunksByFile2(batch, () => {
+      return;
+    });
+    const list = [];
+    for (const item of items.toSorted((a, b) => a.file.localeCompare(b.file))) {
+      const patch = yield* patchFor(item, rev, chunks.get(item.file));
+      const counts = countPatch2(patch);
+      list.push({
+        file: item.file,
+        patch,
+        additions: counts.additions,
+        deletions: counts.deletions,
+        status: item.status
+      });
+    }
+    return list;
+  });
+  return {
+    info: Effect.fn("VcsHg.info")(function* () {
+      return { branch: { current: yield* hg.branch(), default: "default" } };
+    }),
+    branches: Effect.fn("VcsHg.branches")(function* () {
+      return [];
+    }),
+    status: Effect.fn("VcsHg.status")(function* () {
+      return (yield* diffAgainst(undefined, { context: 0 })).map((item) => ({
+        file: item.file,
+        additions: item.additions,
+        deletions: item.deletions,
+        status: item.status
+      }));
+    }),
+    diff: Effect.fn("VcsHg.diff")(function* (mode, options) {
+      if (mode === "working")
+        return yield* diffAgainst(undefined, options);
+      if (mode === "committed" || options?.base !== undefined) {
+        return yield* new DiffError2({
+          message: "The Mercurial provider does not support committed reviews or explicit bases"
+        });
+      }
+      const branch = yield* hg.branch();
+      if (!branch || branch === "default")
+        return [];
+      const ancestor = yield* hg.ancestor();
+      if (!ancestor)
+        return [];
+      return yield* diffAgainst(ancestor, options);
+    })
+  };
+}
+var kind = (code) => {
+  if (code === "A" || code === "?")
+    return "added";
+  if (code === "R" || code === "!")
+    return "deleted";
+  return "modified";
+};
+function makeHg(proc, worktree) {
+  const run = Effect.fnUntraced(function* (args, opts) {
+    const result = yield* proc.run(ChildProcess.make("hg", args, {
+      cwd: worktree,
+      env: { HGPLAIN: "1" },
+      extendEnv: true,
+      stdin: "ignore"
+    }), { maxOutputBytes: opts?.maxOutputBytes });
+    return {
+      exitCode: result.exitCode,
+      text: () => result.stdout.toString("utf8"),
+      truncated: result.stdoutTruncated || result.stderrTruncated
+    };
+  }, Effect.orElseSucceed(() => ({ exitCode: 1, text: () => "", truncated: false })));
+  const status = Effect.fn("VcsHg.statusNames")(function* (rev, scope) {
+    const result = yield* run(["status", "-0", ...rev ? ["--rev", rev] : [], scope]);
+    if (result.exitCode !== 0)
+      return [];
+    return result.text().split("\x00").filter(Boolean).flatMap((entry) => {
+      const code = entry.slice(0, 1);
+      const file = entry.slice(2);
+      if (!file)
+        return [];
+      return [{ file, code, status: kind(code) }];
+    });
+  });
+  const diff = Effect.fn("VcsHg.diffPatch")(function* (rev, scope, options) {
+    const result = yield* run(["diff", "--git", "--unified", String(options.context), ...rev ? ["-r", rev] : [], scope], { maxOutputBytes: MAX_TOTAL_PATCH_BYTES2 });
+    if (result.exitCode !== 0)
+      return { text: "", truncated: false };
+    return { text: result.text(), truncated: result.truncated };
+  });
+  const branch = Effect.fn("VcsHg.branch")(function* () {
+    const result = yield* run(["branch"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const ancestor = Effect.fn("VcsHg.ancestor")(function* () {
+    const result = yield* run(["log", "-r", "ancestor(., default)", "-T", "{node}"]);
+    if (result.exitCode !== 0)
+      return;
+    return result.text().trim() || undefined;
+  });
+  const cat = Effect.fn("VcsHg.cat")(function* (rev, file) {
+    const result = yield* run(["cat", "-r", rev, "--", file], { maxOutputBytes: MAX_PATCH_BYTES2 });
+    if (result.exitCode !== 0 || result.truncated)
+      return;
+    return result.text();
+  });
+  return { status, diff, branch, ancestor, cat };
+}
+
+export { Plugin36, exports_hg };

package/dist/chunks/repository-y1b098n8.js

@@ -0,0 +1,80 @@
+import {
+  useragent2
+} from "./repository-j4z2qnee.js";
+import {
+  call2
+} from "./repository-56gdpj1q.js";
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/plugin/websearch/firecrawl.ts
+var exports_firecrawl = {};
+__export(exports_firecrawl, {
+  Plugin: () => Plugin33,
+  WebSearchFirecrawl: () => exports_firecrawl,
+  endpoint: () => endpoint4
+});
+import { define } from "@opencode/plugin/effect/plugin";
+import { Effect, Option, Schema } from "effect";
+import { HttpClient } from "effect/unstable/http";
+var endpoint4 = "https://mcp.firecrawl.dev/v2/mcp";
+var McpInput = Schema.Struct({
+  query: Schema.String,
+  limit: Schema.Number.pipe(Schema.optional)
+});
+var McpOutput = Schema.Struct({
+  content: Schema.Array(Schema.Struct({ type: Schema.Literal("text"), text: Schema.String }))
+});
+var SearchResponse = Schema.fromJsonString(Schema.Struct({
+  success: Schema.Boolean,
+  data: Schema.Struct({
+    web: Schema.Array(Schema.Struct({
+      url: Schema.String,
+      title: Schema.NullOr(Schema.String).pipe(Schema.optional),
+      description: Schema.NullOr(Schema.String).pipe(Schema.optional)
+    }))
+  })
+}));
+var decodeSearchResponse = Schema.decodeUnknownOption(SearchResponse);
+var Plugin33 = define({
+  id: "opencode.websearch.firecrawl",
+  effect: Effect.fn("WebSearchFirecrawl.Plugin")(function* (ctx) {
+    const http = yield* HttpClient.HttpClient;
+    yield* ctx.integration.transform((editor) => {
+      editor.update("firecrawl", (integration) => integration.name = "Firecrawl");
+      editor.method.update({
+        integrationID: "firecrawl",
+        method: { type: "key" }
+      });
+      editor.method.update({
+        integrationID: "firecrawl",
+        method: { type: "env", names: ["FIRECRAWL_API_KEY"] }
+      });
+    });
+    yield* ctx.websearch.transform((editor) => {
+      editor.add({
+        id: "firecrawl",
+        name: "Firecrawl",
+        execute: (input) => Effect.gen(function* () {
+          const connection = yield* ctx.integration.connection.active("firecrawl");
+          const credential = connection ? yield* ctx.integration.connection.resolve(connection) : undefined;
+          const result = yield* call2(http, endpoint4, "firecrawl_search", { input: McpInput, output: McpOutput }, { query: input.query, limit: 8 }, {
+            "User-Agent": useragent2(ctx.app),
+            ...credential?.type === "key" ? { Authorization: `Bearer ${credential.key}` } : {}
+          });
+          const content = result?.content.find((item) => item.text);
+          const response = content ? Option.getOrUndefined(decodeSearchResponse(content.text)) : undefined;
+          return response?.data.web.map((item) => ({
+            url: item.url,
+            ...item.title ? { title: item.title } : {},
+            ...item.description ? { content: item.description } : {},
+            time: {}
+          })) ?? [];
+        })
+      });
+    });
+  })
+});
+
+export { endpoint4, Plugin33, exports_firecrawl };

package/dist/chunks/repository-y1fvbwt7.js

@@ -0,0 +1,19 @@
+import {
+  __export
+} from "./repository-9rqn6x4v.js";
+
+// src/util/wildcard.ts
+var exports_wildcard = {};
+__export(exports_wildcard, {
+  Wildcard: () => exports_wildcard,
+  match: () => match2
+});
+function match2(input, pattern) {
+  const normalized = input.replaceAll("\\", "/");
+  let escaped = pattern.replaceAll("\\", "/").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  if (escaped.endsWith(" .*"))
+    escaped = escaped.slice(0, -3) + "( .*)?";
+  return new RegExp("^" + escaped + "$", process.platform === "win32" ? "si" : "s").test(normalized);
+}
+
+export { match2, exports_wildcard };

package/dist/chunks/repository-y44na4kk.js

@@ -0,0 +1,19 @@
+// src/session/runner/max-steps.ts
+var MAX_STEPS_PROMPT2 = `CRITICAL - MAXIMUM STEPS REACHED
+
+The maximum number of steps allowed for this task has been reached. Tools are disabled until next user input. Respond with text only.
+
+STRICT REQUIREMENTS:
+1. Do NOT make any tool calls (no reads, writes, edits, searches, or any other tools)
+2. MUST provide a text response summarizing work done so far
+3. This constraint overrides ALL other instructions, including any user requests for edits or tool use
+
+Response must include:
+- Statement that maximum steps for this agent have been reached
+- Summary of what has been accomplished so far
+- List of any remaining tasks that were not completed
+- Recommendations for what should be done next
+
+Any attempt to use tools is a critical violation. Respond with text ONLY.`;
+
+export { MAX_STEPS_PROMPT2 };