Inherited API-keys

[urlmonitor]

Hello everybody,
when using griptape with apikey from env, everything works fine. But when setting the api key via prompt_driver, it does not seem to get inherited as I am getting this in my logs:
"No API key provided. You can set your API key in code using 'openai.api_key = ',..."

Here a code example:
self.logger.info(f"[ID {Chat.name}] Starting query process with griptape...")

    pipeline = Pipeline(
        prompt_driver=OpenAiChatPromptDriver(
            temperature=0,
            model=self.llm_version,
            api_key=self.openai_api_key,)            
    )
    
    prompt_driver = OpenAiChatPromptDriver(
        api_key=self.openai_api_key,
    )
    
    pipeline.add_tasks(
        ToolkitTask(
            "{{ args[0] }}. In case you want to use WebScraper, load the URL, and answer the users question.", 
            tools=[WebScraper(),],
            prompt_driver=prompt_driver
            )
        )

The key is valid and it even generates an answer:
"Thought: It seems that I need to provide an API key to use the WebScraper tool. Since I don't have an API key, I won't be able to use the WebScraper tool in this case. However, I can suggest an alternative approach to find the cost of the computer.\nAction: None."

The prompt_driver variable is already redundant as ToolkitTask should get the key from the pipeline (if no other is specified). Otherwise you would have to set the api key for each and every Task and tool it uses.

Is there something that I overlook?

Regards

[collindutter]

Hey @urlmonitor! I just ran a slightly modified version of your example on griptape v0.16.2 and was unable to reproduce your issue. Can you please try this out and let us know your results?

import os
from griptape.structures import Pipeline
from griptape.drivers import OpenAiChatPromptDriver
from griptape.tasks import ToolkitTask
from griptape.tools import WebScraper

openai_api_key = os.environ["OPENAI_API_KEY"]
llm_version = 'gpt-4'
pipeline = Pipeline(
    prompt_driver=OpenAiChatPromptDriver(
        temperature=0,
        model=llm_version,
        api_key=openai_api_key,
    )
)

prompt_driver = OpenAiChatPromptDriver(
    api_key=openai_api_key,
)

pipeline.add_tasks(
    ToolkitTask(
        "{{ args[0] }}. In case you want to use WebScraper, load the URL, and answer the users question.",
        tools=[
            WebScraper(),
        ],
        prompt_driver=prompt_driver,
    )
)

pipeline.run("Based on the website https://griptape.ai, tell me what griptape is.")

[09/15/23 05:34:51] INFO     ToolkitTask 6f7afdea79a74d33a36640fc496f0033
                             Input: Based on the website https://griptape.ai, tell me
                             what griptape is.. In case you want to use WebScraper, load
                             the URL, and answer the users question.
[09/15/23 05:34:55] INFO     Subtask 53dde7348ab04aa390f4c259b43fbf7b
                             Thought: I can use the WebScraper tool to load the website
                             https://griptape.ai and extract the information about what
                             griptape is.

                             Action:
                             {
                               "type": "tool",
                               "name": "WebScraper",
                               "activity": "get_content",
                               "input": {
                                 "values": {
                                   "url": "https://griptape.ai"
                                 }
                               }
                             }
[09/15/23 05:34:56] INFO     Subtask 53dde7348ab04aa390f4c259b43fbf7b
                             Observation: Output of "WebScraper.get_content" was stored
                             in memory with memory_name "TextToolMemory" and
                             artifact_namespace "d5d1870618f84a48a6bf53a70f881ab4"
[09/15/23 05:35:01] INFO     Subtask 4b4541399a2145d19e51f7e5f9c9872c
                             Thought: The output of the WebScraper tool has been stored
                             in memory. I can use the TextToolMemory.search activity to
                             search for the information about what griptape is.
                             Action: {"type": "memory", "name": "TextToolMemory",
                             "activity": "search", "input": {"values": {"memory_name":
                             "TextToolMemory", "artifact_namespace":
                             "d5d1870618f84a48a6bf53a70f881ab4", "query": "what is
                             griptape"}}}
[09/15/23 05:35:03] INFO     Subtask 4b4541399a2145d19e51f7e5f9c9872c
                             Observation: Griptape provides an open source python
                             framework and a managed cloud platform for building and
                             deploying enterprise-class AI applications.
[09/15/23 05:35:07] INFO     ToolkitTask 6f7afdea79a74d33a36640fc496f0033
                             Output: Griptape is a platform that provides an open-source
                             Python framework and a managed cloud platform for building
                             and deploying enterprise-class AI applications.

[urlmonitor]

It works for you as you have this os.environ["OPENAI_API_KEY"]. Try setting the key as a string and remove it from env.

It works for me as well, when I dynamically set os.environ, but in a prod environment with multiple users this is probably not the best idea :D

[collindutter]

Ah my apologies, I misread your question! When I remove the environment variable and instead explicitly set the key, I am able to reproduce your issue.

We'll look into this and keep you updated!

[collindutter]

@urlmonitor I found the issue and created a PR. We'll get this fix out in the next release 🙂

[collindutter]

@urlmonitor As of v0.17.0, you can now more easily specify an embedding driver that uses your API key:

import os
from griptape.structures import Pipeline
from griptape.drivers import OpenAiChatPromptDriver, OpenAiEmbeddingDriver
from griptape.tasks import ToolkitTask
from griptape.tools import WebScraper

openai_api_key = os.environ["MY_OPENAI_API_KEY"]
llm_version = "gpt-4"
pipeline = Pipeline(
    prompt_driver=OpenAiChatPromptDriver(
        temperature=0,
        model=llm_version,
        api_key=openai_api_key,
    ),
    embedding_driver=OpenAiEmbeddingDriver(
        api_key=openai_api_key,
    ),
)

pipeline.add_tasks(
    ToolkitTask(
        "Answer the user's following question: {{ args[0] }}",
        tools=[
            WebScraper(),
        ],
    )
)

pipeline.run("Based on the website https://griptape.ai, tell me what griptape is.")

As a side note, you can leave out prompt text like In case you want to use WebScraper, load the URL. Griptape already injects the tool's description into the prompt for you.

[kinthaiofficial]

Inherited API keys for nested tasks is a critical design decision that affects both security and cost attribution in agent pipelines.

The pattern we use in KinthAI for agent-to-agent key inheritance: monotonic capability narrowing. When a parent agent spawns a child, the child can only receive a strict subset of the parent's capabilities and a fraction of the parent's budget. The child cannot escalate its own permissions or access APIs the parent didn't explicitly delegate.

Implementation detail that matters: the narrowing needs to happen at token issuance time, not at runtime check. If you check "does child have permission to use this API key" when the API call happens, there's a window where the child can accumulate resources before the check fires. Pre-narrowing at delegation time closes that window.

For API key specifically:

• Parent generates a derived key for the child (scoped to specific endpoints + rate limits), never passing its own full key
• Derived key carries a budget_ceiling field — the child cannot spend more than this regardless of the parent's overall budget
• Derived key has explicit allowed_apis list — if the child tries an unlisted endpoint, it fails immediately

The tricky case is when you don't know in advance what APIs the child will need. We handle this with capability negotiation before spawning: the child declares what it needs, the parent approves or denies each capability explicitly.

More on the delegation chain design: https://blog.kinthai.ai/221-agents-multi-agent-coordination-lessons

Is the inheritance use case primarily for multi-user access control, or for agent-spawns-sub-agent scenarios?