Question: Recommended way of `Context` extension

[tSte]

I'm trying to find the idiomatic way to inject references to custom objects (e.g. a database handle, an API client, a service container) to agent context so that they're accessible from everywhere within an invocation. Tools, plugins, and agent callbacks alike. I wanted to ask what is the recommended way of doing this?

Thanks!

[kalenkevich]

Hello! Could you share a few more details about what you are trying to achieve?

If I understand your intent correctly, you shouldn't need to modify the core ADK models or services directly.
Instead, you can:

• Create custom models that extend BaseModel or GeminiModel and implement your customizations there
• Use plugins and callbacks to hook into different lifecycle events and define custom logic before or after they execute

Please let us know your specific use case, and we will be happy to follow up with a more detailed response!

[tSte]

Hey,

I have an object that contains per-session logic. And I want to be able to access this object from either plugins or tools. I don't know if the domain/semantic of the object are relevant, so let's assume someObject.

What I'd like to do vaguely resembles following:

Module A

import { FunctionTool } from '@google/adk'
import { z } from 'zod'

export const getWeather = new FunctionTool({
  name: 'get_weather',
  description: 'Get the current weather for a city',
  parameters: z.object({
    city: z.string().describe('City name'),
  }),
  // I want to be able to do this with plugins and callbacks as well
  execute: async ({ city }, { someObject }) => ({ foo: someObject.foo(city) }),
})

Module B

import { LlmAgent, InMemoryRunner } from '@google/adk'
import { someObjectFactory } from '../some-utils.ts'
import { getWeather } from '../weather.ts'

const agent = new LlmAgent({
  name: 'weather_agent',
  model: 'gemini-2.5-flash',
  instruction: 'Answer weather questions using the get_weather tool.',
  tools: [getWeather],
})

const userId = 'user-1'
const session = await runner.sessionService.createSession({
  appName: agent.name,
  userId,
})

const runner = new InMemoryRunner(agent)

// Something like this. Not sure if runner / session / etc. are right places to inject objects to context - I guess this is up for discussion
const someObject = someObjectFactory(session.id) // but possibly other params
runner.injectContext({ someObject })

for await (const event of runner.runAsync({
  userId,
  sessionId: session.id,
  newMessage: { role: 'user', parts: [{ text: 'Weather in Prague?' }] },
})) {
  if (event.content) console.log(JSON.stringify(event.content.parts))
}

Right now, we are doing this using a key cache (something like this - more like pseudocode):

import someObject from './some-utils'

const getWeather = new FunctionTool({
  name: 'get_weather',
  description: 'Get the current weather for a city',
  parameters: z.object({
    city: z.string().describe('City name'),
  }),
  execute: async ({ city }, ctx) => {
    if (!ctx) return // because context can be empty for some reason
    const sessionId = ctx.state['temp:sessionId']
    const foo = someObject.get(sessionId).foo(city)
    return { foo }
  }
})

... and it works, but I'd like to have a bit more "native" way how to access session-specific and/or configuration-specific objects/functions from agent context. I also realize that I could wrap tools into a factory-like function and just inject this into a function scope rather than context, but this grows not-so-nice very quickly.

@kalenkevich does it make sense?

[github-actions]

Are you satisfied with the resolution of your issue?
Yes
No