T14 — Effect-based lazy tool init với service injection

{`
export namespace Tool {
  export const define = <P extends z.ZodType, R>(
    id: string,
    // init là Effect, R channel = services cần thiết (Truncate, Agent)
    init: Effect.Effect<Definition<P, R>, never, Truncate | Agent>,
  ) => {
    return Effect.gen(function* () {
      // Resolve services MỘT LẦN tại define-time
      const def     = yield* init
      const truncate = yield* Truncate
      const agent   = yield* Agent

      // Trả về tool đã được wrap — execute luôn có truncation + tracing
      return wrap(id, def, truncate, agent)
    })
  }

  // wrap intercepts execute cho mọi tool
  function wrap<P, R>(
    id: string,
    def: Definition<P, R>,
    truncate: Truncate,
    agent: Agent,
  ) {
    return {
      ...def,
      execute: (args: z.infer<P>, ctx: ExecuteCtx) =>
        Effect.withSpan(`Tool.execute`, {
          attributes: { "tool.name": id, "session.id": ctx.sessionId },
        })(
          def.execute(args, ctx).pipe(
            Effect.tap((result) => truncate.apply(id, result)),
          ),
        ),
    }
  }
}
`}

{`
export const BashTool = Tool.define(
  "bash",
  Effect.gen(function* () {
    // Tool author chỉ cần yield services mà TOOL CỤ THỂ cần
    const session = yield* Session.Ops

    return {
      description: renderTemplate(DESCRIPTION, { PLATFORM: process.platform }),
      parameters: z.object({ command: z.string(), timeout: z.number().optional() }),

      // execute KHÔNG cần nghĩ về truncation hay tracing — wrap lo hết
      async execute(args, ctx) {
        const result = await runBash(args.command, args.timeout)
        await session.setToolStatus(ctx.callId, "completed")
        return result  // ← sẽ tự động bị truncate bởi wrap()
      },
    }
  })
)
`}

{`
function defineTool<A>(id: string, factory: (deps: Deps) => ToolDef<A>) {
  // Resolve deps một lần
  const deps = resolveDeps()   // Truncate, Agent, etc.
  const base = factory(deps)

  return {
    ...base,
    execute: async (args: A, ctx: Ctx) => {
      const span = tracer.startSpan(`tool.${id}`)
      try {
        const raw = await base.execute(args, ctx)
        return deps.truncate(raw)    // auto truncate
      } finally {
        span.end()
      }
    },
  }
}
`}

{`
// 1. Định nghĩa interface Deps
interface ToolDeps {
  truncate: (toolId: string, output: string) => string
  tracer: Tracer
  config: AgentConfig
}

// 2. Factory function nhận deps một lần
function createTools(deps: ToolDeps) {
  function define<Args>(id: string, def: ToolDef<Args>) {
    return {
      ...def,
      execute: async (args: Args, ctx: Ctx) => {
        const span = deps.tracer.startSpan(`tool.${id}`, { sessionId: ctx.sessionId })
        try {
          const raw = await def.execute(args, ctx)
          return deps.truncate(id, raw)
        } catch (err) {
          span.recordException(err)
          throw err
        } finally {
          span.end()
        }
      },
    }
  }

  return {
    bash: define("bash", { description: "...", execute: bashHandler }),
    edit: define("edit", { description: "...", execute: editHandler }),
  }
}

// 3. Bootstrap một lần khi start
const tools = createTools({
  truncate: createTruncate({ maxLines: 2000, maxBytes: 50_000 }),
  tracer: opentelemetry.trace.getTracer("opencode"),
  config: await loadAgentConfig(),
})
`}