import { Effect } from "effect";import type { Executor, ToolId, ToolMetadata, ToolSchema, InvokeOptions, Source } from "@executor/sdk";import type { SandboxToolInvoker } from "@executor/codemode-core";import { ExecutionToolError } from "./errors"; /** * Bridges QuickJS `tools.someSource.someOp(args)` calls into * `executor.tools.invoke(toolId, args)`. */export const makeExecutorToolInvoker = (  executor: Executor,  options: { readonly invokeOptions: InvokeOptions },): SandboxToolInvoker => ({  invoke: ({ path, args }) =>    Effect.gen(function* () {      const result = yield* executor.tools.invoke(        path as ToolId,        args,        options.invokeOptions,      ).pipe(        Effect.catchTag("ElicitationDeclinedError", (err) =>          Effect.fail(            new ExecutionToolError({              message:                `Tool "${err.toolId}" requires approval but the request was ${err.action === "cancel" ? "cancelled" : "declined"} by the user.`,              cause: err,            }),          ),        ),      );      if (result.error !== null && result.error !== undefined) {        return yield* Effect.fail(result.error);      }      return result.data;    }),}); export type ToolDiscoveryResult = {  readonly path: string;  readonly name: string;  readonly description?: string;  readonly sourceId: string;  readonly score: number;}; export type ExecutorSourceListItem = {  readonly id: string;  readonly name: string;  readonly kind: string;  readonly runtime?: boolean;  readonly canRemove?: boolean;  readonly canRefresh?: boolean;  readonly toolCount: number;}; type SearchableTool = Pick<ToolMetadata, "id" | "sourceId" | "name" | "description">; type PreparedField = {  readonly raw: string;  readonly tokens: readonly string[];}; const SEARCH_FIELD_WEIGHTS = {  path: 12,  sourceId: 8,  name: 10,  description: 5,} as const; const normalizeSearchText = (value: string): string =>  value    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")    .replace(/[_./:-]+/g, " ")    .toLowerCase()    .trim(); const tokenizeSearchText = (value: string): string[] =>  normalizeSearchText(value)    .split(/[^a-z0-9]+/)    .map((token) => token.trim())    .filter(Boolean); const prepareField = (value?: string): PreparedField => ({  raw: normalizeSearchText(value ?? ""),  tokens: tokenizeSearchText(value ?? ""),}); const scorePreparedField = (  query: string,  queryTokens: readonly string[],  field: PreparedField,  weight: number,): {  readonly score: number;  readonly matchedTokens: ReadonlySet<string>;  readonly exactPhraseMatch: boolean;} => {  if (field.raw.length === 0) {    return {      score: 0,      matchedTokens: new Set<string>(),      exactPhraseMatch: false,    };  }   let score = 0;  const matchedTokens = new Set<string>();  const exactPhraseMatch = query.length > 0 && field.raw.includes(query);   if (query.length > 0) {    if (field.raw === query) {      score += weight * 14;    } else if (field.raw.startsWith(query)) {      score += weight * 9;    } else if (exactPhraseMatch) {      score += weight * 6;    }  }   for (const token of queryTokens) {    if (field.tokens.includes(token)) {      score += weight * 4;      matchedTokens.add(token);      continue;    }     if (field.tokens.some((candidate) => candidate.startsWith(token) || token.startsWith(candidate))) {      score += weight * 2;      matchedTokens.add(token);      continue;    }     if (field.raw.includes(token)) {      score += weight;      matchedTokens.add(token);    }  }   return {    score,    matchedTokens,    exactPhraseMatch,  };}; const matchesNamespace = (  tool: SearchableTool,  namespace?: string,): boolean => {  if (!namespace || normalizeSearchText(namespace).length === 0) {    return true;  }   const namespaceTokens = tokenizeSearchText(namespace);  if (namespaceTokens.length === 0) {    return true;  }   const sourceTokens = tokenizeSearchText(tool.sourceId);  const pathTokens = tokenizeSearchText(tool.id);   const isPrefixMatch = (tokens: readonly string[]): boolean =>    namespaceTokens.every((token, index) => tokens[index] === token);   return isPrefixMatch(sourceTokens) || isPrefixMatch(pathTokens);}; const scoreToolMatch = (  tool: SearchableTool,  query: string,): ToolDiscoveryResult | null => {  const normalizedQuery = normalizeSearchText(query);  const queryTokens = tokenizeSearchText(query);   if (normalizedQuery.length === 0 || queryTokens.length === 0) {    return null;  }   const path = prepareField(tool.id);  const sourceId = prepareField(tool.sourceId);  const name = prepareField(tool.name);  const description = prepareField(tool.description);   const fieldScores = [    scorePreparedField(normalizedQuery, queryTokens, path, SEARCH_FIELD_WEIGHTS.path),    scorePreparedField(normalizedQuery, queryTokens, sourceId, SEARCH_FIELD_WEIGHTS.sourceId),    scorePreparedField(normalizedQuery, queryTokens, name, SEARCH_FIELD_WEIGHTS.name),    scorePreparedField(normalizedQuery, queryTokens, description, SEARCH_FIELD_WEIGHTS.description),  ];   const matchedTokens = new Set<string>();  let score = 0;  let exactPhraseMatch = false;   for (const fieldScore of fieldScores) {    score += fieldScore.score;    exactPhraseMatch ||= fieldScore.exactPhraseMatch;    for (const token of fieldScore.matchedTokens) {      matchedTokens.add(token);    }  }   if (matchedTokens.size === 0) {    return null;  }   const coverage = matchedTokens.size / queryTokens.length;  const minimumCoverage = queryTokens.length <= 2 ? 1 : 0.6;   if (coverage < minimumCoverage && !exactPhraseMatch) {    return null;  }   if (coverage === 1) {    score += 25;  } else {    score += Math.round(coverage * 10);  }   if (path.tokens[0] === queryTokens[0] || name.tokens[0] === queryTokens[0]) {    score += 8;  }   if (normalizeSearchText(tool.id) === normalizedQuery || normalizeSearchText(tool.name) === normalizedQuery) {    score += 20;  }   return {    path: tool.id,    name: tool.name,    description: tool.description,    sourceId: tool.sourceId,    score,  };}; /** What `tools.search()` calls inside the sandbox. */export const searchTools = (  executor: Executor,  query: string,  limit = 12,  options?: { readonly namespace?: string },): Effect.Effect<ReadonlyArray<ToolDiscoveryResult>> =>  Effect.gen(function* () {    if (normalizeSearchText(query).length === 0) {      return [];    }     const all = yield* executor.tools.list();    return all      .filter((tool: ToolMetadata) => matchesNamespace(tool, options?.namespace))      .map((tool: ToolMetadata) => scoreToolMatch(tool, query))      .filter((tool): tool is ToolDiscoveryResult => tool !== null)      .sort((left, right) => right.score - left.score || left.path.localeCompare(right.path))      .slice(0, limit);  }); /** What `tools.executor.sources.list()` calls inside the sandbox. */export const listExecutorSources = (  executor: Executor,  options?: { readonly query?: string; readonly limit?: number },): Effect.Effect<ReadonlyArray<ExecutorSourceListItem>> =>  Effect.gen(function* () {    const normalizedQuery = normalizeSearchText(options?.query ?? "");    const limit = options?.limit ?? 200;    const sources = yield* executor.sources.list();     const filtered = normalizedQuery.length === 0      ? sources      : sources.filter((source: Source) => {          const haystack = normalizeSearchText([            source.id,            source.name,            source.kind,          ].join(" "));          return tokenizeSearchText(normalizedQuery).every((token) => haystack.includes(token));        });     const withCounts = yield* Effect.forEach(      filtered,      (source: Source) =>        executor.tools.list({ sourceId: source.id }).pipe(          Effect.map((tools) => ({            id: source.id,            name: source.name,            kind: source.kind,            runtime: source.runtime,            canRemove: source.canRemove,            canRefresh: source.canRefresh,            toolCount: tools.length,          } satisfies ExecutorSourceListItem)),        ),      { concurrency: "unbounded" },    );     return withCounts      .sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id))      .slice(0, limit);  }); /** What `tools.describe.tool()` calls inside the sandbox. */export const describeTool = (  executor: Executor,  path: string,): Effect.Effect<  {    path: string;    name: string;    description?: string;    inputTypeScript?: string;    outputTypeScript?: string;    typeScriptDefinitions?: Record<string, string>;  },  unknown> =>  Effect.gen(function* () {    const metadata = (yield* executor.tools.list()).find(      (t: ToolMetadata) => t.id === path,    );     const base = {      path,      name: metadata?.name ?? path,      description: metadata?.description,    };     const schema: ToolSchema = yield* executor.tools.schema(path);    return {      ...base,      inputTypeScript: schema.inputTypeScript,      outputTypeScript: schema.outputTypeScript,      typeScriptDefinitions: schema.typeScriptDefinitions,    };  });